精华内容
下载资源
问答
  • java字符串转unicode

    2018-08-01 09:58:04
    这里提供一个能转换十进制和十六进制unicode的java的util类,我们经常会遇到乱码问题,比如在后端与前端交互的时候,由于框架的种种原因,导致乱码,这时候就用到了unicode(万能码),在乱码前转为unicode,就可以...
  • Java算法之对字符串的各种处理

    千次阅读 2020-03-09 21:57:52
    JAVA算法题之字符串处理 一、找出字符串中出现最多的字符 对于这个题目我给大家提供两个思路,一个就是常规的思路双重for循环遍历,另一个就是利用map的特性 。 思路一:时间复杂度高n^2,遍历n*n次 public class ...

    JAVA算法题之字符串处理

    一、找出字符串中出现最多的字符

    对于这个题目我给大家提供两个思路,一个就是常规的思路双重for循环遍历,另一个就是利用map的特性 。
    思路一:时间复杂度高n^2,遍历n*n次
    public class Stringways {
        @Test//出现最多的字符
        public void test1() {
            String str = "fbasfbaihsbbdiasaaaa";
            //统计每一个字符出现了多少次
            char res = str.charAt(0);
            int max = 0;//最多出现了多少次
            for (int i = 0; i < str.length(); i++) {
                char temp = str.charAt(i);
                int count = 0;
                for (int j = 0; j < str.length(); j++) {
                    if (str.charAt(j) == temp) {
                        count++;//计算temp出现了多少次
                    }
                }
                if (count >= max) {
                        max = count;
                        res = temp;
                    }
            }
            System.out.println(res + "出现次数最多:" + max);
        }
    
    思路二:有关次数的问题我们可以利用map的键值对特性(值,次数),想法的话也不是特别难。
    @Test
      public void test2() {//统计每个字符出现的字数,出现最多的,出现最少的。
          String str = "fbasfbaihsbbdiasaaaa";
          char res = str.charAt(0);
          int max = 0;//最多出现了多少次
          Map<Character, Integer> map = new HashMap<>();
          for (int i = 0; i < str.length(); i++) {
              char c =  str.charAt(i);
              Integer count = map.get(c);
              if(count == null ){
                  //字符没有出现过
                  count = 1;
              }else {
                  count++;
              }
              map.put(c, count);
              if (count>max){
                  res = c;
                  max = count;
              }
          }
          System.out.println(res + "出现次数最多:" + max);
      }
    
    统计每个字符出现的字数,出现最多的,出现最少的都可以使用这种方法,不一一举例,理解思路。

    二、找出字符串中第一次重复出现的字符。

    对于这个题目大家可以从重复入手,在集合框架Set集合的特点:一个无序(存入和取出顺序有可能不一致)容器,不可以存储重复元素,只允许存入一个null元素,必须保证元素唯一性。(推荐)
     public void test2_1(){
          String str = "asdngfjssd";
          Set<Character> set = new HashSet<>();
          for (int i = 0; i < str.length(); i++) {
              if(!set.add(str.charAt(i))){
                  //set里的add方法返回boolean类型值,
                  // 没有重复set返回true证明没有 重复了set返回false已经存在了
                  System.out.println(str.charAt(i));
                  break;
              }
          }
      }
    
    题目也可以用map实现,Hashset底层其实使用Hashmap实现,我们只需要保证不出现重复的键名就可以,map.containsKey()方法判断是否包含指定的键名。

    三、找出字符串中第一个只出现一次的字符。

    思路一:考虑使用map,统计每个字符出现的次数,然后从前到后遍历找到第一个次数为一的字符就是所要找的。
    @Test
     public void test3(){
         String str = "asdnfsdfssd";
         Map<Character, Integer> map = new HashMap<>();
         for (int i = 0; i < str.length(); i++) {
             char c =  str.charAt(i);
             Integer count = map.get(c);
             if(count == null ){
                 //字符没有出现过
                 count = 1;
             }else {
                 count++;
             }
             map.put(c, count);
         }
         for (int i = 0; i < str.length(); i++) {
             if (map.get(str.charAt(i))==1){
                 System.out.println(str.charAt(i));
                 break;
             }
         }
     }
    
    思路二:指定字符第一次出现的位置和最后一次出现的位置一样就是第一个只出现一次的字符,使用string给我们提供的api,indexOf()方法:查找一个字符串中,第一次出现指定字符串的位置。lastIndexOf()方法:返回指定字符在此字符串中最后一次出现处的索引。
    @Test
      public void test3_2(){
          String str = "asdnfsdfssd";
          for (int i = 0; i < str.length(); i++) {
              char m =  str.charAt(i);
              if(str.indexOf(m)==str.lastIndexOf(m)){
                  System.out.println(m);
                  break;
              }
          }
      }      
    

    今天就分享到这里,之后会继续更新,路过的小伙伴感觉不错的可以帮忙点赞,有其他想法的同学可以评论留言互相交流,本人看到后会第一时间回复的。

    展开全文
  • Java字符串模板格式化汇总8法(附性能对比) 结论: 1.循环中,不要用+进行字符串拼接,而用StringBuilder.append()方法 2.非循环中,字符串拼接使用+性能最高,其次是StringBuilder.append()方法 1. ++ ...

    Java字符串模板格式化汇总8法(附性能对比)

     

    结论: 

    1. 循环中, 不要用+进行字符串拼接, 而用StringBuilder.append()方法

    2. 非循环中, 字符串拼接使用+性能最高, 其次是StringBuilder.append()方法

     

     

     

     

     

    1. ++

    对于初学JAVA的蒙童,大约都会使用这招

    @Test
    public void testAdd(){
    
        Date now = new Date();
    
        String yearMonth = DateUtil.toString(now, DatePattern.YEAR_AND_MONTH);
        String expressDeliveryType = "sf";
        String fileName = DateUtil.toString(now, DatePattern.TIMESTAMP);
    
        String template = "/home/expressdelivery/" + yearMonth + "/" + expressDeliveryType + "/vipQuery_" + fileName + ".log";
    
        System.out.println(template);
    }

    输出 :

    /home/expressdelivery/2017-07/sf/vipQuery_20170723042314.log

    2. StringBuffer / StringBuilder

    @Test
    public void testStringBuilder(){
    
        Date now = new Date();
    
        String yearMonth = DateUtil.toString(now, DatePattern.YEAR_AND_MONTH);
        String expressDeliveryType = "sf";
        String fileName = DateUtil.toString(now, DatePattern.TIMESTAMP);
    
        StringBuilder sb = new StringBuilder();
        sb.append("/home/expressdelivery/");
        sb.append(yearMonth);
        sb.append("/");
        sb.append(expressDeliveryType);
        sb.append("/vipQuery_");
        sb.append(fileName);
        sb.append(".log");
    
        String template = sb.toString();
    
        System.out.println(template);
    }

    输出 :

    /home/expressdelivery/2017-07/sf/vipQuery_20170723042603.log

    缺点:

    • 代码太长了

    3. StringUtil.format(String, Object…​)

    使用 com.feilong.core.lang.StringUtil.format(String, Object…​)

    内部封装了 String.format(String, Object)

    @Test
    public void testStringFormat(){
        Date now = new Date();
    
        String yearMonth = DateUtil.toString(now, DatePattern.YEAR_AND_MONTH);
        String expressDeliveryType = "sf";
        String fileName = DateUtil.toString(now, DatePattern.TIMESTAMP);
    
        String template = StringUtil.format("/home/expressdelivery/%s/%s/vipQuery_%s.log", yearMonth, expressDeliveryType, fileName);
    
        System.out.println(template);
    }

    输出 :

    /home/expressdelivery/2017-07/sf/vipQuery_20170723043153.log

    4. MessageFormatUtil.format(String, Object…​)

    使用 com.feilong.core.text.MessageFormatUtil.format(String, Object…​)

    内部封装了 java.text.MessageFormat.format(String, Object…​)

    @Test
    public void testMessageFormat(){
        Date now = new Date();
    
        String yearMonth = DateUtil.toString(now, DatePattern.YEAR_AND_MONTH);
        String expressDeliveryType = "sf";
        String fileName = DateUtil.toString(now, DatePattern.TIMESTAMP);
    
        String template = MessageFormatUtil
                        .format("/home/expressdelivery/{0}/{1}/vipQuery_{2}.log", yearMonth, expressDeliveryType, fileName);
    
        System.out.println(template);
    }

    输出 :

    /home/expressdelivery/2017-07/sf/vipQuery_20170723043153.log

    5. Slf4jUtil.format(String, Object…​)

    使用 com.feilong.tools.slf4j.Slf4jUtil.format(String, Object…​)

    借助 slf4j 日志占位符

    @Test
    public void testSlf4jFormat(){
        Date now = new Date();
    
        String yearMonth = DateUtil.toString(now, DatePattern.YEAR_AND_MONTH);
        String expressDeliveryType = "sf";
        String fileName = DateUtil.toString(now, DatePattern.TIMESTAMP);
    
        String template = Slf4jUtil.format("/home/expressdelivery/{}/{}/vipQuery_{}.log", yearMonth, expressDeliveryType, fileName);
    
        System.out.println(template);
    }

    输出:

    /home/expressdelivery/2017-07/sf/vipQuery_20170723144236.log

    6. StringUtil.replace(CharSequence, Map<String, V>)

    使用 com.feilong.core.lang.StringUtil.replace(CharSequence, Map<String, V>)

    内部封装了 apache commons-lang3 org.apache.commons.lang3.text.StrSubstitutor , 现在叫 commons-text

    使用给定的字符串 templateString 作为模板,解析匹配的变量 .

    @Test
    public void testReplace(){
        Date date = new Date();
        Map<String, String> map = new HashMap<>();
        map.put("yearMonth", DateUtil.toString(date, YEAR_AND_MONTH));
        map.put("expressDeliveryType", "sf");
        map.put("fileName", DateUtil.toString(date, TIMESTAMP));
    
        String template = StringUtil.replace("/home/expressdelivery/${yearMonth}/${expressDeliveryType}/vipQuery_${fileName}.log", map);
    
        System.out.println(template);
    }

    输出:

    /home/expressdelivery/2017-07/sf/vipQuery_20170723144608.log

    优点:

    • 模块可以定义变量名字了,不怕混乱

    Note

    此方法只能替换字符串,而不能像el表达式一样使用对象属性之类的来替换

    7. VelocityUtil.parseString(String, Map<String, ?>)

    使用 com.feilong.tools.velocity.VelocityUtil.parseString(String, Map<String, ?>)

    该方法需要 jar

    <dependency>
      <groupId>com.feilong.platform.tools</groupId>
      <artifactId>feilong-tools-velocity</artifactId>
      <version>${version.feilong-platform}</version>
    </dependency>
    @Test
    public void testVelocityParseString(){
        Date date = new Date();
    
        Map<String, String> map = new HashMap<>();
        map.put("yearMonth", DateUtil.toString(date, YEAR_AND_MONTH));
        map.put("expressDeliveryType", "sf");
        map.put("fileName", DateUtil.toString(date, TIMESTAMP));
    
        VelocityUtil velocityUtil = new VelocityUtil();
    
        String template = velocityUtil
                        .parseString("/home/expressdelivery/${yearMonth}/${expressDeliveryType}/vipQuery_${fileName}.log", map);
    
        System.out.println(template);
    }

    输出

    /home/expressdelivery/2017-07/sf/vipQuery_20170723145856.log

    8. VelocityUtil.parseTemplateWithClasspathResourceLoader(String, Map<String, ?>)

    使用 com.feilong.tools.velocity.VelocityUtil.parseTemplateWithClasspathResourceLoader(String, Map<String, ?>)

    该方法需要 jar

    <dependency>
      <groupId>com.feilong.platform.tools</groupId>
      <artifactId>feilong-tools-velocity</artifactId>
      <version>${version.feilong-platform}</version>
    </dependency>

    该方法适合于 字符串模板独立成文件, 方便维护

    路径是classpath 下面, 比如 velocity/path.vm

    28497395 a52f617c 6fb8 11e7 9902 66249985242a

    此时代码需要如此调用:

    @Test
    public void testVelocityParseTemplateWithClasspathResourceLoader(){
        Date date = new Date();
    
        Map<String, String> map = new HashMap<>();
        map.put("yearMonth", DateUtil.toString(date, YEAR_AND_MONTH));
        map.put("expressDeliveryType", "sf");
        map.put("fileName", DateUtil.toString(date, TIMESTAMP));
    
        VelocityUtil velocityUtil = new VelocityUtil();
    
        String template = velocityUtil.parseTemplateWithClasspathResourceLoader("velocity/path.vm", map);
    
        System.out.println(template);
    }

    输出 :

    /home/expressdelivery/2017-07/sf/vipQuery_20170723150443.log

    9. 性能对比

    28501853 87f4c8c2 7017 11e7 99db 3b2d47c803a8

    上图是 分别循环 100000, 500000, 1000000, 2000000 统计出来的数据

    在性能上 String format 是最差的

    字符串 ++ 最快, StringBuilder 次之 , slf4j 的格式化再次之

    测试硬件概览:

    型号名称:	MacBook Pro
    处理器名称:	Intel Core i5
    处理器速度:	2.9 GHz
    内存:	16 GB

    10. 参考

     

     

    转载:

    Java字符串模板格式化汇总8法(附性能对比) - 飞天奔月的个人空间 - OSCHINA
    https://my.oschina.net/venusdrogon/blog/1486633

     

     

     

     

     

     

     

    ========================================================================

    ========================================================================

    ========================================================================

     

     

    字符串连接你用+还是用StringBuilder - 掘金
    https://juejin.im/post/5b2af17de51d4558c713507c#heading-2

     

     

     

     

     

     

    字符串连接你用+还是用StringBuilder

    前言

    据我所知字符串确实已经成为 Java 开发人员最常用的类了,而且是大量使用。我们都知道,String 其实是封装了字符,所以俩字符串连接就是将字符串对象里面的字符连起来。很多人习惯使用+来连接字符串,也有人会用 StringBuilder 的append方法。

    "+"编译后

    看看如果我们在程序中直接使用+来连接字符串的情况,用下面一个简单的例子来说明,进行两个字符串连接操作,即s3 = s1 + s2

    public class TestString {
    	public static void main(String[] args) {
    		String s1 = "www";
    		String s2 = "ccc";
    		String s3 = s1 + s2;
    	}
    }
    复制代码

    接着javap -c TestString.class看一下编译后的情况,可以看到编译器其实是对+进行了转换的,转成了 StringBuilder 对象来操作了,首先使用 s1 创建 StringBuilder 对象,然后用 append方法连接 s2,最后调用toString方法完成。

    public class com.seaboat.string.TestString {
      public com.seaboat.string.TestString();
        Code:
           0: aload_0
           1: invokespecial #8                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: ldc           #16                 // String www
           2: astore_1
           3: ldc           #18                 // String ccc
           5: astore_2
           6: new           #20                 // class java/lang/StringBuilder
           9: dup
          10: aload_1
          11: invokestatic  #22                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
          14: invokespecial #28                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
          17: aload_2
          18: invokevirtual #31                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          21: invokevirtual #35                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
          24: astore_3
          25: return
    }
    复制代码

    "+"与"append"等价吗

    前面可以看到+在编译器作用下都会转成 StringBuilder 的append方法执行,所以如果抛开运行效率来说,它们其实本质是一样的。

    本质一样是否就能说明它们时等价的呢?或者说能否为了方便直接用+来连接字符串,剩下的事就交给编译器了?继续看个例子,在这个例子中有个 for 循环进行字符串连接操作。

    public class TestString2 {
    	public static void main(String[] args) {
    		String s = "www";
    		for (int i = 0; i < 10; i++)
    			s += i;
    	}
    }
    复制代码

    编译后的情况如下,不熟悉指令没关系,我们只看重要的部分,if_icmplt 8,这个就是 for 循环的条件判断,小于10则不断跳到8的位置,8后面其实就是创建 StringBuilder 对象,并以本地变量s的值初始化该对象,接着再将本地变量i append到 StringBuilder 对象中,最后调用toString方法将所得值存到本地变量s。

    这样来看循环中每次都要创建 StringBuilder 对象,而且要调用toString方法,这样的执行效率显然比较低,而且增加了 GC 的压力。

    public class com.seaboat.string.TestString2 {
      public com.seaboat.string.TestString2();
        Code:
           0: aload_0
           1: invokespecial #8                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: ldc           #16                 // String www
           2: astore_1
           3: iconst_0
           4: istore_2
           5: goto          30
           8: new           #18                 // class java/lang/StringBuilder
          11: dup
          12: aload_1
          13: invokestatic  #20                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
          16: invokespecial #26                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
          19: iload_2
          20: invokevirtual #29                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
          23: invokevirtual #33                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
          26: astore_1
          27: iinc          2, 1
          30: iload_2
          31: bipush        10
          33: if_icmplt     8
          36: return
    }
    复制代码

    友好写法

    把事情都丢给编译器是不友好的,为了能让程序执行更加高效,最好是我们自己来控制 StringBuilder 的实例,比如下面,只创建一个 StringBuilder 实例,后面用append方法连接字符串。

    public class TestString3 {
    	public static void main(String[] args) {
    		StringBuilder sb = new StringBuilder("www");
    		for (int i = 0; i < 10; i++)
    			sb.append(i);
    	}
    }
    复制代码

    编译后的情况如下,首先创建一个 StringBuilder 对象,使用字符串"www"来实例化该对象,接着循环调用append方法将本地变量i添加到 StringBuilder 对象中。

    public class com.seaboat.string.TestString3 {
      public com.seaboat.string.TestString3();
        Code:
           0: aload_0
           1: invokespecial #8                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: new           #16                 // class java/lang/StringBuilder
           3: dup
           4: ldc           #18                 // String www
           6: invokespecial #20                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
           9: astore_1
          10: iconst_0
          11: istore_2
          12: goto          24
          15: aload_1
          16: iload_2
          17: invokevirtual #23                 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
          20: pop
          21: iinc          2, 1
          24: iload_2
          25: bipush        10
          27: if_icmplt     15
          30: return
    }
    复制代码

     

     

     

     

     

     

    展开全文
  • java 字符数组与字符串 Java通常会排在前五种最流行的编程语言中,因此可以理解。 它是一种通用语言,非常容易学习,因为它是一种高级语言,并且可以满足许多用例。 由于这些原因,Java是一门很棒的语言,可以用来...

    java 字符数组与字符串

    Java通常会排在前五种最流行的编程语言中,因此可以理解。 它是一种通用语言,非常容易学习,因为它是一种高级语言,并且可以满足许多用例。 由于这些原因,Java是一门很棒的语言,可以用来学习您是否有经验,还是刚开始您的软件工程生涯。

    Java可能是一种相对容易学习的语言,但这并不意味着我们不会时有问题,不会陷入困境,也不会忘记该语言的细微差别。 这篇文章的目的是为您提供有关如何在Java框架内执行特定操作的简要信息,称为EdPresso Shots 。 在本文中,我们将介绍与字符串和数组相关的操作方法。

    让我们开始吧。

    如何在Java中查找字符串的长度

    要计算Java中字符串的长度,可以使用Java 字符串类的内置length()方法

    在Java中,字符串是使用字符串类创建的对象,而length()方法是此类的公共成员方法。 因此,任何类型为string的变量都可以使用来访问此方法 (点)运算符。

    length()方法计算字符串中的字符总数。

    length()方法的签名如下:

    • 公共int 长度()
    • length()方法的返回类型为int。

    例:

    Class CalcLength {
      public static void main (string args[]) {
        string name = "educative"; // initializing a string object name
        int length = name.length(); // calling the inbuilt length method
        system.out.println("The length of the string \""+name+"\" is: " +length);
        }
    }

    输出=字符串“教育性”的长度为9。

    有兴趣了解更多Java操作方法吗? 查看Educative的Edpresso镜头 -开发人员知识的字节大小的镜头。

    如何在Java中使用compareTo()方法比较字符串?

    Java compareTo()方法根据字符串中每个字符的Unicode值按字典顺​​序(与字典中的顺序相似将给定的字符串与当前字符串进行比较。 此方法在实现时返回一个整数。

    Java字典顺序如下:

    • 号码
    • 大写
    • 小写

    三种情况下使用compareTo()方法:

    情况1:两个字符串在字典上是等效的

    如果两个字符串相等,则该方法返回0(零)。

    class MyClass {
      public static void main (string args[]) {
        string str1 = "abcd";
        string str2 = "abcd";
        system.out.println(str1.compareTo(str2));
      }
    }

    输出= 0

    情况2:字符串调用方法按字典顺序优先

    当按字典顺序调用该方法的字符串排在最前面时,该方法返回一个负数。

    class MyClass {
      public static void main (string args[]) {
        string str1 = "abCd";
        string str2 = "abcd";
        system.out.println(str1.compareTo(str2));
      }
    }

    输出= -32

    情况3:方法中传递的参数按字典顺序排在最前面

    当方法中传递的参数按字典顺序排在最前面时,该方法将返回一个正数。

    class MyClass {
      public static void main (string args[]) {
        string str1 = "abcd";
        string str2 = "abCd";
        system.out.println(str1.compareTo(str2));
      }
    }

    该数字表示作为输入参数传递的字符串str2和调用方法的字符串str1的Unicode值之间的差。

    结果 = str2的Unicode – str1的Unicode

    如何在Java中获取子字符串

    Java中的substring()方法返回字符串的一部分,并用于获取Java中的子字符串。

    Java中substring()方法实现有两种变体:

    变体1我们指定了一个起始索引,返回的子字符串包括从输入字符串的指定起始索引开始直到字符串末尾的字符。

    子字符串函数表示如下: stringName.substring(int startindex)

    class HelloWorld {
      public static void main (string args[]) {
        string str = "edpresso";
        system.out.println(str.substring(2));
      }
    }

    输出=压力

    变体2

    我们指定开始索引和结束索引,返回的子字符串包含指定索引之间包含和的字符。 获取子字符串时,包含开始索引处的字符,但不包含结束索引处的字符。 因此,提取的子字符串中的字符从开始索引到结束索引-1开始。

    子字符串函数也可以表示为: stringName.substring(int startIndex,int endIndex)

    class HelloWorld {
      public static void main(string args[]) {
        string str = "edpresso";
        system.out.println(str.substring(2,7));
      }
    }

    注意: substring()方法不会更改原始字符串。

    如何在Java中初始化数组

    声明数组声明数组的语法是:

    数据类型[] arrayName;

    • 数据类型:将存储在数组中的对象的类型,例如 int,char等
    • []:指定声明的变量指向数组
    • arrayName:指定数组的名称

    初始化数组

    声明数组不会初始化它。 为了将值存储在数组中,我们必须首先对其进行初始化,其语法如下:

    数据类型[] arrayName =新数据类型[大小];

    有几种不同的初始化数组的方法:

    1.初始化数组而不分配值

    可以将数组初始化为特定大小。 在这种情况下,每个元素的默认值为0。

    class HelloWorld {
      public static void main(string args[]) {
        // intializing an array
        int[]array = new int[5];
        //printing the elements of array
        for(int i = 0; i < 5; i++)
        {
          system.out.println(array[i]);
        }
      }
    }

    2.在声明后初始化数组

    class HelloWorld {
      public static void main(string args[]) {
        //array declaration
        int[]array;
        //array initialization
        array = new int[]{1, 2, 3, 4, 5};
        //printing the elements of array
        for(int i; i < 5; i++)
        {
          system.out.println(array[i]);
        }
      }
    }

    注意:将数组分配给已声明的变量时,必须使用new关键字。

    3.初始化数组并分配值

    lass HelloWorld {
      public static void main(string args[]) {
        int[]array = {11, 12, 13, 14, 15};
        //printing the elements of array
        for(int i = 0; i < 5; i++)
        {
          system.out.println(array[i]);
        }
      }
    }

    注意:在初始化期间将值分配给数组时,未指定大小。

    如何在Java中使用二维数组

    类似于一维数组,二维数组是数据单元的集合。 在大多数情况下,二维数组的工作方式与一维数组相同。 但是,与一维数组不同,它们允许您同时指定列索引和行索引。

    2D阵列中的所有数据均为同一类型。

    声明二维数组

    与一维数组类似,我们必须指定数组的数据类型,名称和大小。 二维数组的大小由行数和列数声明。 例如:

    class Testarray {
      public static void main(string args[]) {
        int number_of_rows = 6;
        int number_of_columns = 5;
        int arr[][] = new int[number_of_rows][number_of_columns];
      }
    }

    此二维数组中的元素总数为:number_of_rows * number_of_columns因此,arr中的元素总数为30。

    初始化二维数组

    //initializing a 2-D array
    int arr[][] = {{1, 2, 3},{4, 5, 6},{7,8,9}};

    访问二维数组

    像一维数组一样,您可以通过使用指定要访问的单元格索引的下标来访问二维数组中的各个单元格。 但是,您现在必须指定两个索引而不是一个。 表达式如下所示:

    arr[2][3] = 5;
    system.out.println(arr[2][3]); // prints out 5
    • 2是行索引
    • 3是列索引
    • 5是该索引处的值

    您还可以使用以下语法找到行或列的长度:

    arr[2][].length; // prints length of 3rd row 
    arr[][0].length; // prints length of 1st column

    如果您想查看更多有关Java,Python,C / C ++和许多其他语言的字节大小的EdPresso快照 ,可以访问Educative.io

    学习愉快!

    翻译自: https://www.javacodegeeks.com/2019/12/5-simple-and-effective-java-techniques-for-strings-and-arrays.html

    java 字符数组与字符串

    展开全文
  • Java字符串模版

    千次阅读 2016-12-08 13:28:35
    Java字符串模版

    转载文章:

    http://www.jb51.net/article/67058.htm

    http://www.cnblogs.com/fsjohnhuang/p/4094777.html


    一、String.format方法

    占位符: %[index$][标识]*[最小宽度][.精度]转换符

       % :占位符的其实字符,若要在占位符内部使用%,则需要写成 %% 。
      [index$] :位置索引从1开始计算,用于指定对索引相应的实参进行格式化并替换掉该占位符。
      [标识] :用于增强格式化能力,可同时使用多个 [标识] ,但某些标识是不能同时使用的。
      [最小宽度] :用于设置格式化后的字符串最小长度,若使用 [最小宽度] 而无设置 [标识] ,那么当字符串长度小于最小宽度时,则以左边补空格的方式凑够最小宽度。
      [.精度] :对于浮点数类型格式化使用,设置保留小数点后多少位。
      转换符 :用于指定格式化的样式,和限制对应入参的数据类型。

    1、字符串格式化

    占位符: %[index$][标识][最小宽度]转换符
    可用标识:

                 -:在最小宽度内左对齐,右边用空格补上。

    转换符:

                s:字符串类型

                c:字符类型,实参必须为char或int、short等可转换为char类型的数据类型,否则抛出异常

                b:布尔类型,只要实参为非false的布尔类型,均格式化为字符串true,否则为字符串false

                n:平台独立的换行符

    package com.learns.format;
    
    public class StringTest {
    	public static void main(String[] args) {
    		
    		String str = String.format("%1$s %2$s", "Hello","World!");
    		System.out.println(str);
    	}
    }
    

    2、对整数进行格式化

    占位符: %[index$][标识]*[最小宽度]转换符

    可用标识:

                -:在最小宽度内左对齐,不可以与0标识一起使用

                0:若内容长度不足最小宽度,则在左边用0来填充

                #:对8进制和16进制,8进制前添加一个0,16进制前添加0x

                +:结果总包含一个+或-号

                空格:正数前加空格,负数前加-号

                ,:只用于十进制,每3位数字间用,分隔

                (:若结果为负数,则用括号括住,且不显示符号

    转换符:

                 b:布尔类型,只要实参为非false的布尔类型,均格式化为字符串true,否则为字符串false

                 d:整数类型(十进制)

                 x:整数类型(十六进制)

                 o:整数类型(八进制)

                 n:平台独立的换行符

    package com.learns.format;
    
    public class StringTest {
    
    	public static void main(String[] args) {
    		// 0001 (1,000)
    		String str = String.format("%1$04d %2$(,d",1,-1000);
    		System.out.println(str);
    	}
    }
    

    3、对浮点数进行格式化

    占位符: %[index$][标识]*[最小宽度][.精度]转换符
    可用标识:

                -:在最小宽度内左对齐,不可以与0标识一起使用

                0:若内容长度不足最小宽度,则在左边用0来填充

                #:对8进制和16进制,8进制前添加一个0,16进制前添加0x

                +:结果总包含一个+或-号

                空格:正数前加空格,负数前加-号

                ,:只用于十进制,每3位数字间用,分隔

                (:若结果为负数,则用括号括住,且不显示符号

    转换符:

                 b:布尔类型,只要实参为非false的布尔类型,均格式化为字符串true,否则为字符串false

                 n:平台独立的换行符

                 f:浮点数型(十进制)。显示9位有效数字,且会进行四舍五入。如99.99

                 a:浮点数型(十六进制)

                 e:指数类型。如9.38e+5

                 g:浮点数型(比%f,%a长度短些,显示6位有效数字,且会进行四舍五入)

    package com.learns.format;
    
    public class StringTest {
    
    	public static void main(String[] args) {
    		// 123.457
    		String str = String.format("%.3f",123.456789);
    		System.out.println(str);
    	}
    }
    

    4、对日期时间进行格式化

    占位符: %[index$]t转换符

    日期转换符:       

                 c:星期六 十月 27 14:21:20 CST 2007
                 F:2007-10-27
                 D:10/27/07
                 r:02:25:51 下午
                 T:14:28:16
                 R:14:28
                 b:月份简称
                 B: 月份全称
                 a:星期简称
                 A: 星期全称
                 C:年前两位(不足两位补零)
                 y:年后两位(不足两位补零)
                 j:当年的第几天
                m:月份(不足两位补零)
                d:日期(不足两位补零)
                e:日期(不足两位不补零)

    时间转换符:

                H: 24小时制的小时(不足两位补零)
                k:24小时制的小时(不足两位不补零)
                I:12小时制的小时(不足两位补零)
                i:12小时制的小时(不足两位不补零)
                M:分钟(不足两位补零)
                S:秒(不足两位补零)
                L:毫秒(不足三位补零)
                N:毫秒(不足9位补零)
                p:小写字母的上午或下午标记,如中文为“下午”,英文为pm
                z:相对于GMT的时区偏移量,如+0800
                Z:时区缩写,如CST
                s:自1970-1-1 00:00:00起经过的秒数
                Q:自1970-1-1 00:00:00起经过的豪秒

    package com.learns.format;
    
    import java.util.Date;
    
    public class StringTest {
    
    	public static void main(String[] args) {
    		/*
    		 * 结果
    		 * 星期四 十二月 08 09:55:21 CST 2016
    		 *  2016-12-08
    		 *  12/08/16
    		 */
    		Date date = new Date();
    		String str = String.format("%1$tc %n %2$tF %n %3$tD",date,date,date);
    		System.out.println(str);
    	}
    }
    

    5、其他转换符

    <:用于格式化前一个转换符所描述的参数

    package com.learns.format;
    
    import java.util.Date;
    
    public class StringTest {
    
    	public static void main(String[] args) {
    		/*
    		 * 结果
    		 * 星期四 十二月 08 09:55:21 CST 2016
    		 *  2016-12-08
    		 *  12/08/16
    		 */
    		Date date = new Date();
    		String str = String.format("%tc %n %<tF %n %<tD",date);
    		System.out.println(str);
    	}
    }
    

    二、MessageFormat

    占位符:

    { ArgumentIndex }
    { ArgumentIndex , FormatType }
    { ArgumentIndex , FormatType , FormatStyle }
    ArgumentIndex:入参位置索引

    FormatType:指定使用不同的Format子类对入参进行格式化处理。取值范围:

                         number:调用NumberFormat进行格式化

                         date:调用DateFormat进行格式化

                         time:调用DateFormat进行格式化

                         choice:调用ChoiceFormat进行格式化

    FormatStyle:设置FormatType中使用的格式化样式。取值范围:short、medium、long、full、integer、currency、percent、SubformatPattern(子格式模式,形如#.##)

    示例:

    1、{0}和{1,number,short}和{2,number,#.#};都属于FormatElement,0,1,2是ArgumentIndex。
    2、{1,number,short}里面的number属于FormatType,short则属于FormatStyle。
    3、{1,number,#.#}里面的#.#就属于子格式模式。
    指定FormatType和FormatStyle是为了生成日期格式的值、不同精度的数字、百分比类型等等。

    package com.learns.format;
    
    import java.text.MessageFormat;
    
    public class FormatTest {
    	public static void main(String[] args) {
    		String value = MessageFormat.format("{0,number,#.#} is good num",Double.valueOf("3.14"));
    		System.out.println(value);
    	}
    }
    

    使用注意:

    1、格式化字符串时,两个单引号才标识一个单引号,单个单引号会被忽略,中文单引号不会被忽略。

    package com.learns.format;
    
    import java.text.MessageFormat;
    
    public class FormatTest {
    
    	public static void main(String[] args) {
    		// 单个单引号
    		String str = MessageFormat.format("This is {0} 'we' play!","why");
    		System.out.println(str);
    		// 两个单引号
    		String str2 = MessageFormat.format("This is {0} ''we'' play!","why");
    		System.out.println(str2);
    		// 中文单引号
    		String str3 = MessageFormat.format("This is {0} ‘we’ play!","why");
    		System.out.println(str3);
    	}
    }
    

    结果:

    This is why we play!
    This is why 'we' play!
    This is why ‘we’ play!

    2、单引号会使其后面的占位符均失败,导致直接输出占位符。

    package com.learns.format;
    
    import java.text.MessageFormat;
    
    public class FormatTest {
    
    	public static void main(String[] args) {
    		// 添加一个单引号在占位符前,占位符失败 
    		String str = MessageFormat.format("This is '{0} {1} play!","why","we");
    		System.out.println(str);
    		// 占位符添加一对单引号,单个占位符失败
    		String str2 = MessageFormat.format("This is '{0}' {1} play!","why","we");
    		System.out.println(str2);
    		// 占位符添加两个单引号,正常使用
    		String str3 = MessageFormat.format("This is ''{0}'' {1} play!","why","we");
    		System.out.println(str3);
    	}
    }
    
    结果:

    This is {0} {1} play!
    This is {0} we play!
    This is 'why' we play!

    3、要单独使用左花括号,需要使用单引号。否则会出现异常

    package com.learns.format;
    
    import java.text.MessageFormat;
    
    public class FormatTest {
    
    	public static void main(String[] args) {
    		// 使用花括号
    		String str = MessageFormat.format("This is '{'{0}} {1} play!","why","we");
    		System.out.println(str);
    		// 出现两个或两个以上左花括号,会分割字符串。(与占位符连接会报错,如{{0})
    		String str2 = MessageFormat.format("This is {{ {0} {1} play!","why","we");
    		System.out.println(str2);
    	}
    }
    
    结果:
    This is {why} we play!
    This is 

    4、每调用一次MessageFormat.format方法,都会新创建MessageFormat的一个实例。因此若多次使用同一模式字符串,创建一个MessageFormat实例比较好。

    源代码:

    public static String format(String pattern, Object ... arguments) {
            MessageFormat temp = new MessageFormat(pattern);
            return temp.format(arguments);
        }


    总结:

    对于简单的格式化或字符串组装,使用MessageFormat.format。格式化处理更丰富要使用String.format方法


    展开全文
  • Java框架总结

    万次阅读 多人点赞 2020-01-17 14:14:13
    本系列用来记录常用java框架的基本概念、区别及联系,也记录了在使用过程中,遇到的一些问题的解决方法,方便自己查看,也方便大家查阅。 欲速则不达,欲达则欲速! 一、SSH 1、基本概念 SSH框架JAVA EE中三种...
  • Java字符串匹配相似度算法

    千次阅读 2018-12-19 11:34:50
    * 采用动态规划的方法(字符串匹配相似度) * @param source 源 * @param target 要匹配的字符串 * @return */ public static int EditDistance(String source, String target) { char[] source...
  • 在做拼音搜索的时候,发现了一个问题,现有的contains或者indexOfAt都是判断是否包含连续的字符串,但我的需求是包含不连续的字符串,所以我做了一下的一个接军方法,希望能帮助到大家。 代码如下 其中p例如abcdef ...
  • 上面的代码也是较为核心的部分 ,就是将我们的字符串转换成一个java类,然后编译成class 重点看call(), call(): 此方法就是进行动态编译可执行的代码 编译完成后,会返回boolean 为true表示编译成功,反之则, ...
  • 设定字符串为“张三,你好,我是李四” 产生张三的密钥对(keyPairZhang) 张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节 通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到张三编码后...
  • 有人工智能系列(常用深度学习框架TensorFlow、pytorch、keras。NLP、机器学习,深度学习等等),大数据系列(Spark,Hadoop,Scala,kafka等),程序员必修系列(C、C++、java、数据结构、linux,设计模式、数据库等等)...
  • 剑指Offer_24 字符串的排序 2018/6/19 星期二 题目描述 输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和...
  • Java数值型和字符串互转锦集【收藏备用】

    千次阅读 多人点赞 2020-06-23 10:36:48
    大家好,我是灰小猿,今天来和大家分享一下Java中常用的数值型和字符串数据的相互转换。 注意:字符型指的是char型,而string为字符串,两者是不同的,所以在这里是数值型和字符串之间的相互转换! 先将常用的数值...
  • .首先我们来认识一下 java中的一个对象 JavaCompiler JavaCompiler : 不知道肯定很陌生,其实这...Java的反射 : 这个我不多做介绍了,程序中很常见,基本上java程序员都会接触到,列入金典的框架 spring 等等 /** ...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • java 中操作字符串都有哪些类?它们之间有什么区别? String、StringBuffer、StringBuilder String : final修饰,String类的方法都是返回new String。即对String对象的任何改变都不影响到原对象,对字符串的修改...
  • 使用的是jfinal框架,用到maven。现在要根据字符串生成二维码,并且显示到jsp页面。
  • 检查自己的字符串是否有问题-开始没写任何类型。通过debug找到是参数类型问题。把#换成了 $类型 对比后发现两者可能会导致注入的问题。后面通过jdbcType 设置类型。可是我要传到数据库的值是Integer...
  • Java Html字符串转PDF

    千次阅读 2018-07-13 16:57:25
    很多直接字符串写入pdf的包对于html的格式太严谨,没结束标签一言不合就拦掉,出现只渲染一半的情况; 2.不大支持html5的样式,如:h2 .title{},.a .b{},li.a{}这些情况不能生效; 3.网上很多都碰到中文乱码,...
  • java中json字符串java对象的转换

    千次阅读 2020-11-02 16:23:09
    1、Java与前台的交互2、解析JSON的第三方工具3、JSON数据和Java对象的相互转换Java对象转换JSON字符串JSON字符串转为Java对象 1、Java与前台的交互 作为后台,Java不仅需要接收前台传递过来的数据,还需要...
  • web应用采用的是ssh框架,数据库使用的sql server2014版本。 二、问题: 客户要求,ID列的数据类型必须是uniqueidentifier,一开始实体类的ID设计成java.lang.String类型;映射文件中ID的增长方式是uuid.hex ...
  • 正如标题所述,这是一个替换java字符串中${}或者{}等占位符的工具类,其处理性能比较丽令人满意。该类主要通过简单的改写myatis框架中的GenericTokenParser类得到。在日常开发过程中,可以该类进行简单的改进或封装...
  • java模板字符串解析(占位符解析)

    千次阅读 2019-09-12 22:18:20
    项目中常常需要解析字符串模板,比如user:{userId}:{userType}用于redis的key等,比较常见的做法就是使用String.format("user:%s:%s", 1, 1)方法,但个人感觉那样的模板不够明了,而使用模板解析器可更好地有助于...
  • Java方法字符串调用 这是一种基于Java反射框架的编程语言字节码的事实用于控制反射调用目标
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • Java字符串模板替换

    千次阅读 2015-08-09 10:00:16
    Java字符串模板替换 源代码下载地址:http://www.zuidaima.com/share/1593989887085568.htm
  • 前言: 关于如何转换网上的文章已经很多了,我之所以还写出来的主要目的是提供一下jar。很多博主只是提供json-lib包,其他依赖的包让自己去下载,自己在这里遇到一些坑就是,...JSON-lib框架,转换JSON、XML不再困难
  • Java的单元测试经常需要构造各种测试数据,其中一项就是构造测试的字符串。 如果我们想要随机构造人名、地名、天气、学校、颜色、职业,甚至符合某正则表达式的字符串等,肿么办? 那么有一个库叫 java-fake 可以...
  • Netty简介Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说,Netty 是一个基于NIO的客户、服务器端...
  • java对象转换为xml格式字符串

    千次阅读 2017-06-13 22:35:49
    它提供了管理实现 JAXB 绑定框架操作所需的 XML/Java 绑定信息的抽象,这些操作包括:解组、编组和验证。 1.编写工具类 /** * Jaxb工具类 * * @author LittleNewbie * @date 2016年10月11日 */ public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 264,879
精华内容 105,951
关键字:

java字符串处理框架

java 订阅