Java 数组&字符串_java定义字符串数组

java数组&字符串

java数组的定义方法

int[] anArray={1,2,3,4,5};
int anArray[]=new int[10]{1,2,3,4,5,6,7,8,9,0}
String strArray[]=new String[10];//int 未初始化默认为0/0.0，String为null
数组的遍历一般for/foreach
for(int index=0;index<anArray.length;index++){
	System.out.println(anArray[index])
}
for(String element:strArray
){
	System.out.println(element)
}
切记使用双引号！！
1
2
3
4
5
6
7
8
9
10
11
12

数组的排序

import java.util.Arrays;
import java.util.Collections;
int aArray[] = new int[]{1, 5, 8, 3, 34, 0};
Arrays.sort(aArray);
Integer bArray[] = new Integer[]{1, 5, 8, 3, 34, 0};
Arrays.sort(bArray, Collections.reverseOrder());
1
2
3
4
5
6

Java函数的基本调用

public class Test {
    public static void main(String[] args) {
        String[] varArgs=new String[]{"abc","123","xyz"};
        Test.varargsMethod(varArgs);
    }

    public static void varargsMethod(String... varargs) {
        for (int i = 0; i < varargs.length; i++) {
            System.out.println(varargs[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

打印java数组

import java.util.Arrays;
import java.util.stream.Stream;
public class arrayPrinter {
    public static void main(String[] ars) {
        String[] strArray = new String[]{"沐雨尘子", "学习", "Java"};
//      todo 打印
        for (int index = 0; index < strArray.length; index++) {
            System.out.println(strArray[index]);
        }
//      使用stream来进行第一种：
        Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));
//    第二种：
        Stream.of(strArray).forEach(System.out::println);
//    第三种
        Arrays.stream(strArray).forEach(System.out::println);
        //第四种
        System.out.println(Arrays.toString(strArray));
        System.out.println(Arrays.deepToString(strArray));//二维数组
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

字符串

字符串的不可变，

字符串的定义：String str=“chenzi”;//
使用双引号声明的字符串对象会保存在字符串常量池中
使用new 关键字创建的字符串对象会先从字符串常量池中找，如果没有找到就创建一个，然后再在堆中创建字符串对象，如果找到了就直接在堆中创建字符串对象。

String sTest = "chenzi";
String sTemp="chen"+"zi";
System.out.println(sTemp==sTest);//true
String s=new String("chenzi");
String s1=s.intern();
System.out.println(s==sTemp);//false
System.out.println(s1==sTemp);//true
//另一个
String s1 = new String("chenzi");
String s2 = s1.intern();
System.out.println(s1 == s2);
//答案是false 
因为第一行表示在字符串常量池中创建chenzi字符串，然后在堆中创建一个对象，给s1引用
第二行对s1执行intern()方法，该方法在字符串常量池中查找是否存在，此时存在，然后给s2引用
因为s1是堆中的引用，s2字符串常量池的引用，所以false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

String s1 = new String("chen") + new String("zi");
String s2 = s1.intern();
System.out.println(s1 == s2);
//ture
第一行是在字符串常量池中创建两个对象，然后在堆中创建“chen”和“zi”两个匿名对象，最后创建还有一个chenzi对象，chenzi在堆中的引用给s1
第二行代码是对s1使用intern()，该方法会在字符串常量池中查找“chenzi”这个对象是否存在，此时是不存在的，但是在堆中已经存在了，所以字符串常量池保存的是“chnezi”对象的引用，所以s1,s2这两个引用地址是相同的，所以结果为true.
1
2
3
4
5
6

字符串的比较

==与.equals()这两个比较有点像Python里的 跟is
在java里是对两个对象在内存里的地址是否相等，equals（）是对两个对象的值是否相等。

        String alpha=new String("chenzi");
        String beta=new String("chenzi");
        System.out.println(alpha == beta);//false
        System.out.println(alpha.equals(beta));//true
1
2
3
4

new String("chenzi").equals("chenzi")
equals()是对于值的进行比较，所以为true
new String("chenzi")=="chenzi"
左边是在字符串常量池中查找，没有找到，然后在常量池中创建，最后在堆中创建出的字符串，
右边是常量池中的字符串，尽管值相同，但是内存地址不同false
new String("chenzi") == new String("chenzi")
new出来的对象肯定是完全不同的内存地址，所以false
"chenzi"=="chenzi";
字符串常量池一会有一个相同内容的对象，所以true
"chenzi" == "chen" + "zi";
chen与zi都在字符串常量池，编译器在遇到+会自动优化为chenzi,所以返回true
new String("chenzi").intern()=="chenzi"
左边在字符串常量池创建chenzi对象，然后在堆中创建一个chenzi对象，执行intern()也就是引用chenzi对象，跟右边的chenzi是相同的，字符串常量池不存在相同的。

还有其他的Object.equals() String.contentEquals()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

字符串的拼接

+与append()
+是一种语法糖，在循环体内拼接字符串最好使用StringBuilder的append()方法。

 public static void strMethod() {
        long startTime=System.currentTimeMillis();
        String result = "";
        for (int i = 0; i < 100000; i++) {
            result += "六六六";
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append("六六六");
        }
        long endTime=System.currentTimeMillis();
        System.out.println(endTime-startTime);
经过对比前者大概消耗了3350毫秒，后者7毫秒，这个差距是非常大的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

join函数

	String chenzi="chenzi";
    String test="test";
    String combine=String.join("-",chenzi,test);
    System.out.println(combine);
    //chenzi-test
1
2
3
4
5