前言

Github:https://github.com/HealerJean

博客:http://blog.healerjean.com

JavaUtil包:http://gitbook.net/java/util/index.html

1、Stiring

1.1、 isEmpty、isBlank

isEmpty:判断某字符串是否为空 ,有内容有就为true。

isNotBlank:判断经历过trim后是否为空,判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成,

@Test
public void empty(){
    System.out.println(StringUtils.isEmpty("aaa")); //false
    System.out.println(StringUtils.isEmpty(null)); //true
    System.out.println(StringUtils.isEmpty("")); //true
    System.out.println(StringUtils.isEmpty("\n")); //false
    System.out.println(StringUtils.isEmpty(" "));//false

    System.out.println("-------------------------");
    System.out.println(StringUtils.isBlank("aaa")); //false
    System.out.println(StringUtils.isBlank(null)); //true
    System.out.println(StringUtils.isBlank("")); //true
    System.out.println(StringUtils.isBlank("\n")); //true
    System.out.println(StringUtils.isBlank(" "));//true
}

1.2、String.format:%变量替换

参数 说明
%s 字符串类型,也可以放入其他类型,比如,整数,小数等等
%c 字符类型 ‘m’
%b 布尔类型 true
%d 整数类型(十进制)
%.4f%% 小数 55.1510%
%05d 补齐位数,0 代表前面补充0,5 代表长度为5, d 代表参数为正数型
(不足的打印0,超出的正常显示原始数据)
@Test
public void strisngFormat() {

    String s = "____%s____";
    System.out.println(String.format(s, "mingrisoft")); //____mingrisoft____

    String c = "____%c____";
    System.out.println(String.format(c, 'c')); //____c____

    String b = "____%b____";
    System.out.println(String.format(b, true)); //____true____

    String d = "____%d____";
    System.out.println(String.format(d, 125));//____125____

    String str = "____%s____" + "____%c____" + "____%b____" + "____%d____";
    System.out.println(String.format(str, "mingrisoft", 'c', true, 123));

    System.out.println(String.format("%05d", 24));  //00024
    System.out.println(String.format("%05d", 123456)); //123456
}
    

1.3、MessageFormat.format

注意:格式化字符串时,两个单引号才表示一个单引号,单个单引号会被省略

/**
* 3、MessageFormat.format,占位符替换
* 注意:格式化字符串时,两个单引号才表示一个单引号,单个单引号会被省略
*/
@Test
public void messageFormat() {
    //1、占位
    String msg = "{0},{1},{2},{3},{4},{5},{6},{7},{8}";
    Object[] array = new Object[]{"A", "B", "C", "D", "E", "F", 1525.12, 10, BigDecimal.ZERO};
    System.out.println(MessageFormat.format(msg, array));
    // 输出:A,B,C,D,E,F,1,525.12,10,0

    System.out.println(MessageFormat.format("oh, {0} is 'a' ''pig''", "ZhangSan"));
    //输出: oh, ZhangSan is a 'pig'
    }

1.4、把原始字符串分割成指定长度的字符串列表



	//把原始字符串分割成指定长度的字符串列表
	@Test
	public void testLengthSplit(){
		System.out.println(getStrList("123456789",3));
	}
	
    /**
     * 把原始字符串分割成指定长度的字符串列表
     * @param inputString  原始字符串
     * @param length   指定长度
     * @return
     */
    public static List<String> getStrList(String inputString, int length) {
        int size = inputString.length() / length;
        if (inputString.length() % length != 0) {
            size += 1;
        }
        return getStrList(inputString, length, size);
    }


    /**
     * 把原始字符串分割成指定长度的字符串列表
     * @param inputString 原始字符串
     * @param length 指定长度
     * @param size  指定列表大小
     * @return
     */
    public static List<String> getStrList(String inputString, int length,
                                          int size) {
        List<String> list = new ArrayList<String>();
        for (int index = 0; index < size; index++) {
            String childStr = substring(inputString, index * length,
                    (index + 1) * length);
            list.add(childStr);
        }
        return list;
    }
    /**
     * 分割字符串,如果开始位置大于字符串长度,返回空
     * @param str  原始字符串
     * @param f 开始位置
     * @param t  结束位置
     * @return
     */
    public static String substring(String str, int f, int t) {
        if (f > str.length())
            return null;
        if (t > str.length()) {
            return str.substring(f, str.length());
        } else {
            return str.substring(f, t);
        }
    }


1.5、比较速度: String.toString() > String.valueOf() > i + ""

@Test
public void testSpeed() {

    int loopTime = 50000;
    Integer i = 0;

    long startTime = System.currentTimeMillis();
    for (int j = 0; j < loopTime; j++) {
        String str = String.valueOf(i);
    }

    System.out.println("String.valueOf():" + (System.currentTimeMillis() - startTime) + "ms");
    startTime = System.currentTimeMillis();
    for (int j = 0; j < loopTime; j++) {
        String str = i.toString();
    }

    System.out.println("Integer.toString():" + (System.currentTimeMillis() - startTime) + "ms");
    startTime = System.currentTimeMillis();
    for (int j = 0; j < loopTime; j++) {
        String str = i + "";
    }
    System.out.println("i + \"\":" + (System.currentTimeMillis() - startTime) + "ms");
}




// 结果
// Integer.toString():6ms
// String.valueOf():21ms
// i + "":38ms

1.6、string 和byte数组的转化

/**
* 6、string 和byte数组的转化
*/
@Test
public  void testbyteArray() throws UnsupportedEncodingException {
    String str = "HealerJean";
    byte[] byteArray;
    byteArray = str.getBytes("utf-8");
    String strByte = new String(byteArray, "UTF-8");
    System.out.println("byte数组:" + byteArray + "\n" + "string:" + strByte);
}

1.7、String 和 StringBuffer之间的转化

@Test
public  void strToBuffer() {
    //String -> StringBuffer 1、构造方法  2、通过append方法
    //创建一个String对象
    String str = "Hi Java!";
    System.out.println(str);

    //方式一:构造方法
    StringBuffer buffer = new StringBuffer(str);
    System.out.println(buffer);

    //方式二:通过append方法
    StringBuffer buffer2 = new StringBuffer();
    buffer2.append(str);
    System.out.println(buffer2);



    //StringBuffer -> String
    //创建一个StringBuffer对象 1、构造方法 2、toString方法
    StringBuffer buffer3 = new StringBuffer();
    buffer3.append("Happy birthday Java!");
    System.out.println(buffer3);

    //方式一:通过构造方法
    String str2 = new String(buffer3);
    System.out.println(str2);

    //方式二:通过toString方法
    String str3 = buffer3.toString();
    System.out.println(str3);
}

1.8、string可不可以 +

如果提前定义对象,是可以的,未提前定义好对象:直接报错

@Test
public void teststringadd() {

    //未提前定义好对象
    //String m = m +"abc"; //错误的

    //如果提前定义对象,是可以的
    String a = "123";
    String b = "";
    b += "abc";
    b = b + "a";
}

1.9、String …不定参数

@Test
public  void printStringMain() {
    printString();
    System.out.println("==========");
    printString(new String[]{"我", "和", "你"});
}
public  void printString(String... str) {
    if (str.length == 0) {
        System.out.println("没有传参数。");
    }
    for (int i = 0; i < str.length; i++) {
        System.out.printf(str[i]);
    }
}

// 没有传参数。
// ==========
// 我和你

1.10、定义数组


@Test
public void array() {
    //1、
    int[] a = new int[3]; //定义一个数组
    a[0] = 1;
    a[1] = 2;
    a[2] = 3;
    //	a[4] = 5; //超出限制 报错

    //2、动态初始化
    int b[];
    //  b[1] = 2;  没有给定大小,报错
    b = new int[5];

    //3、 静态初始化
    //  int c[3] = {1,4,2,3}; 不能给定值
    int c[] = {1, 4, 2, 3};

    //4、new 并直接静态赋值,不可写入大小
    //  int d[] = new int[5]{1,2,3}; 错误
    int d[] = new int[]{1, 2, 3};
}

1.11、substring 截取的是字节还是字符

String类的length()方法是以unicode代码单元,换言之就是char的个数为来统计的。 所以使用subString等截取出来的子串都不会出现半个汉字的情况,因为java一个char类型可以存放一个汉字(2个字节)。而如果以字节byte来截取字符串,就会出现半个汉字的情况。

1.11.1、按字节数截取字符串, 不能截出半个汉字, 如果是半个汉字则舍去!

思路:汉字的unicode编码都是负数,如果这些负数字节在截取的字节数组中成对出现,说明不会截取到半个汉字。如果不是成对出现,则会截取到半个汉字,需要将最后一个字节舍去。

 @Test
    public void testSubStringByteOr() {
        String source = "我是一abcd个好人cccc";
        int byteCount = 8; //表示截取多少个
        byte[] byteArr = source.getBytes();
        System.out.println("字节大小为" + byteArr.length);
        int count = 0;
        // 统计要截取的那部分字节中负数的个数
        for (int i = 0; i < byteCount; i++) {
            if (byteArr[i] < 0) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("负数的个数为" + count);

        // 负数成对出现 则不会出现半个汉字
        if (count % 2 == 0)
            System.out.println(new String(byteArr, 0, byteCount));
            // 负数个数不是偶数,则有半个汉字
        else
            System.out.println(new String(byteArr, 0, byteCount - 1));
    }

1.12、null+字符串的值、字符串+数字

@Test
public void testnull() {
    System.out.println( null + "abc"); // nullabc
    System.out.println( "abc" + (2 + 1)); //abc3
    System.out.println("abc" + 2 + 1); //abc21
}

1.13、字符串是否改变

@Test
public void testChange(){
    String str = "a";
    StringTest stringTest = new StringTest();
    int i = 1;
    int a[] = {1, 2, 3};
    String abc[] = {"a", "b", "c"};
    stringTest.change(str, i, a, abc);
    System.out.println(str); //a 不会改变
    System.out.println(i);//1 不会改变
    System.out.println(a[2]); //56
    System.out.println(abc[2]); //ef
}

void change(String str, int i, int[] a, String abc[]) {
    i = 123;
    str = "abc";
    a[2] = 56;
    abc[2] = "ef";
}

1.14、split

@Test
public void Testsplit() {
    //
    String a = "abcdef";
    String[] aStrings = a.split("");
    System.out.println("0输出" + aStrings[0]); //输出a
    System.out.println("5输出" + aStrings[5]); //输出f
    System.out.println(aStrings.length);  //6

    for (String b : aStrings) {
        System.out.println(b); //a b c d e f
    }
}

1.15、String.intern()分析 -结合1.16看

@:JDK1.6:复制的是字符串,返回常量池字符串地址

@:JDK1.7:复制的是引用,返回引用

判断这个常量是否存在于常量池。

  如果存在

   判断存在内容是引用还是常量,

    如果是引用,

     返回引用地址指向堆空间对象

    如果是常量,

     直接返回常量池常量  

  如果不存在,

   将当前对象引用复制到常量池,并且返回的是当前对象的引用

结合 2 分析

String a1 = "AA";
System.out.println(a1 == a1.intern()); //true   常亮比较 相等

String a2 = new String("B") + new String("B");
a2.intern();
String a3 = new String("B") + new String("B");
System.out.println(a2 == a3.intern());//true  a3.intern是a2的引用,所以相等
System.out.println(a3 == a3.intern());//false


String a4 = new String("C") + new String("C");
System.out.println(a4 == a4.intern()); //true

1.16、创建字符串分析

结1、只在常量池上创建常量

String a1 = "AA";

结2、只在堆上创建对象

String a2 = new String("A") + new String("A");

结3、在堆上创建对象,在常量池上创建常量

    String a3 = new String("AA");

结4、在堆上创建对象,在常量池上创建引用

String a4 = new String("A") + new String("A");//只在堆上创建对象AA
a4.intern();//将该对象AA的引用保存到常量池上

1.16.1、创建字符串分析开始

1.16.1.1、直接使用双引号" "创建字符串

判断这个常量是否存在于常量池,

  如果存在,

   判断这个常量是存在的引用还是常量

     如果是引用,返回引用地址指向的堆空间对象,  

    如果是常量,则直接返回常量池常量,

  如果不存在,

    在常量池中创建该常量,并返回此常量

String a1 = "AA";//在常量池上创建常量AA
String a2 = "AA";//直接返回已经存在的常量AA
System.out.println(a1 == a2); //true
String a3 = new String("AA");    //在堆上创建对象AA,在常量池创建对象AA
a3.intern(); //发现在常量池已经有了字符串AA,所以不做操作,返回字符串AA的地址
String a4 = "AA"; //常量池上存在字符串AA,所以使用常量池中的对象
System.out.println(a3 == a4); //false,    

1.16.1.2、new String创建字符串

1、首先在堆上创建对象(无论堆上是否存在相同字面量的对象

2、然后判断常量池上是否存在字符串的字面量,

  如果不存在

   在常量池上创建常量

  如果存在

   不做任何操作

String a1 = new String("AA");
String a2 = new String("AA");
System.out.println(a1 == a2); //false

//如果常量池上不存在常量AA,也不存在引用AA,则创建常量AA
String a1 = new String("AA");
System.out.println(a1 == a1.intern()); //false // a1是堆上"AA"对象的地址,a1.intern()是字符串常量池中字符串AA对象的地址,所以返回false

1.16.1.3、双引号相加

判断这两个常量、相加后的常量在常量池上是否存在

​   如果不存在

   则在常量池上创建相应的常量

  如果存在

   判断这个常量是存在的引用还是常量,

    如果是引用,返回引用地址指向的堆空间对象,

    如果是常量,则直接返回常量池常量,

String a1 = "AA" + "BB";//在常量池上创建常量AA、BB和AABB,并返回AABB
//常量池上存在常量AABB
String a2 = "AABB";
String a3 = "AA" + "BB";
System.out.println(a2 == a3); //true
//常量池上存在引用AABB
String a4 = new String("AA") + new String("BB"); //在堆上创建对象AA、BB和AABB,在常量池上创建常量AA和BB
a4.intern(); //常量池没有AABB,复制a4的引用到常量池,然后返回a4的引用
String a5 = "AA" + "BB";  //常量池中已经有了AABB的引用,则a5指向的是a4的引用
System.out.println(a4 == a5); //true 

1.16.1.4、两个new String相加

 首先会创建这两个对象以及相加后的对象

 然后判断常量池中是否存在这两个对象的字面量常量

  如果存在

   不做任何操作

  如果不存在

   则在常量池上创建对应常

//常量AA不存在,所以第一步在常量池中创建了常量AA
String a2 = new String("AA") + new String("BB");
String a3 = new String("A") + new String("A"); //创建对象AA,
System.out.println(a3 == a3.intern()); //false  //AA已经在常量池存在了,所以a3.intern() 直接返回字符串AA的地址,然后和引用a3比较,肯定不相等
//只在堆上创建AABB对象,没有在常量池中创建常量AABB
String a2 = new String("AA") + new String("BB");
System.out.println(a2 == a2.intern()); //true 

1.16.2、String创建字符串的问题

String s1 = "a";
String s2 = "a" + "b";
System.out.println(s2 == "ab");//true

String s3 = s1 + "b";
System.out.println(s3 == "ab");//false

1.16.2.1、理解说明

String s = new String("a");

这相当于在java堆内存中创建一个对象

String s = "a" + "b";

java的编译器会为该语句进行优化,变成String s = “ab”;放入的是常量池

1.16.2.2、解答疑问

s3 = s1 + "b";由于编译器不能在编译过程中确定s1的值,所以在这一步相当于String s3 = new String(“ab”);所以s3对象是堆内存中的对象,所以与常量池中的”ab”对比,自然答案是false。

加入把s1变成一个常量,s3 == "ab" 就会为true

final String s1 = "a";
String s2 = "a" + "b";
String s3 = s1 + "b";

System.out.println(s2 == "ab");//true
System.out.println(s3 == "ab");//true

1.16.3、String.intern()问题

1.16.3.1、jdk1.6 :复制的是字符串

String s1 = new String("aaa")+new String("bbb");
s1.intern();
String s2 = "aaabbbb";
System.out.println(s1==s2); //false 引用和字符串比较

1.16.4.2、jdk1.7 :复制的是引用

String s1 = new String("aaa")+new String("bbb");
s1.intern();
String s2 = "aaabbb";
System.out.println(s1==s2); //true 引用和引用比较 
String s1 = new String("aaa")+new String("bbb");
String s2 = "aabbcc";
s1.intern(); //已经存在了字符串,不会受到影响了
System.out.println(s1==s2); //false 

2、Integer

2.1、包装类:Integer内存分配

2.1.1、两个 new Integer() 变量比较 ,永远是 false

生成的是堆内存对象,引用地址不相等 ,比较为false

@Test
public void test1() {
    Integer i = new Integer(100);
    Integer j = new Integer(100);
    System.out.print(i == j);  //false
}

2.1.2、Integer变量 和 new Integer() 变量比较 ,永远为 false

而 new Integer() 的变量指向 堆中 新建的对象

Integer j = 100; -128到127,常量池,之外的也是堆中,但是和new 的不一样

 public void test2() {
        Integer i = new Integer(100);
        Integer j = 100;
        System.out.print(i == j);  //false 常量池和堆中的对象比较

        Integer i2 = new Integer(128);
        Integer j2 = 128;
        System.out.println(i2 == j2); //堆中建立的不同对象的比较
    }

2.1.3、两个Integer 变量比较,-128到127 之间为true

java对于-128到127之间的数,会进行缓存,在常量池存储。

public void test3() {
    Integer i = 100;
    Integer j = 100;
    System.out.println(i == j); //true

    Integer i2 = 128;
    Integer j2 = 128;
    System.out.println(i2 == j2); //false
}

2.1.3、int 变量 与 Integer、 new Integer() 比较时,只要两个的值是相等,则为true

包装类Integer 和 基本数据类型int 比较时,java会自动拆包装为int ,然后进行比较,实际上就变为两个int变量的比较。

int是基本数据类型,不能在对中创建数据,所以堆中的Integer拆箱(xx.intValue)为int类型的数据,然后进行比较int和integer(无论new否)比,都为true,因为会把Integer自动拆箱为int再去比,也就是栈内存中的拆箱后进行比较

@Test
public void test4() {
    Integer i = new Integer(100);
    int j = 100;
    System.out.print(i == j); //true
}

3、List

3.1、remove object/index

测试remove方法 remove(object 或者是 index(int))

/**
 * 1、测试remove方法 remove(object 或者是 index(int))
 */
@Test
public  void RemoveMethod() {
	List<String> stringList = new ArrayList<String>();
	stringList.add("String one");
	stringList.add("String two");

	stringList.remove("String one");
	System.out.println(stringList.size()); //1
	System.out.println(stringList); //[String two]


	stringList.add("String three");
	stringList.remove(0);
	System.out.println("remove 0 也就是去掉 String two");
	System.out.println(stringList); //[String three]


	List<Integer> integerList = new ArrayList<>();
	integerList.add(1);
	integerList.add(2);
	integerList.add(3);
	integerList.remove(0);
	System.out.println(integerList); //[2, 3]


}

1
[String two]
remove 0 也就是去掉 String two
[String three]
[2, 3]


3.3、list 放入有顺序

/**
3、 list 放入有顺序
*/
@Test
public void listHaveAddSort(){
    List<Person> persons= new ArrayList<Person>();
    Person person = new Person(0, "HealerJean");
    Person person2 = new Person(0, "HealerJean");
    persons.add(0,person);
    persons.add(3,person2); //报错,因为没有 2
}

	

3.4、list去重

3.4.1、普通去重

/**
	 4、list 去重
	 */
@Test
public void deleteSim(){
    deleteSimSet();
    delteSimIfContain();
    delteSimAddAllSet();
}

/**
1、set集合去重,不打乱顺序
*/
public void deleteSimSet(){

    System.out.println("1、set集合去重,不打乱顺序");
    List<String> list  =   new  ArrayList<String>();
    list.add("aaa");
    list.add("bbb");
    list.add("aaa");
    list.add("aba");
    list.add("aaa");

    Set set = new  HashSet();
    List newList = new  ArrayList();
    for (String cd:list) {
        if(set.add(cd)){
            newList.add(cd);
        }
    }
    System.out.println( "去重后的集合: " + newList);
}

/**
2、遍历后判断赋给另一个list集合
 */
public void delteSimIfContain(){
    System.out.println("2、遍历后判断赋给另一个list集合");
    List<String> list  =   new  ArrayList<String>();
    list.add("aaa");
    list.add("bbb");
    list.add("aaa");
    list.add("aba");
    list.add("aaa");

    List<String> newList = new  ArrayList<String>();
    for (String cd:list) {
        if(!newList.contains(cd)){
            newList.add(cd);
        }
    }
    System.out.println( "去重后的集合: " + newList);
}



/** 3、
* set.addAll();
* list.add(Set)
*/
public void delteSimAddAllSet(){
    System.out.println("2、遍历后判断赋给另一个list集合");

    List<String> list  =   new  ArrayList<String>();
    list.add("aaa");
    list.add("bbb");
    list.add("aaa");
    list.add("aba");
    list.add("aaa");

    Set set = new  HashSet();
    List newList = new  ArrayList();
    set.addAll(list);
    newList.addAll(set);

    System.out.println( "去重后的集合: " + newList);
}

	

3.4.2、对象去重

/**
* 取出集合 appsAppDataLast 减去 与  appsAppDataFirst 重复的对象 比如 1 2 ,2 3 去重之后就是1
*/
public List<AppsAppData> getRemoveAll(List<AppsAppData> appsAppDataFirst,List<AppsAppData> appsAppDataLast){

    List<AppsAppData> appsAppDatas = new ArrayList<>();
    appsAppDatas.addAll(appsAppDataLast);

    for(AppsAppData appsAppDataL :appsAppDataLast ){
        for (AppsAppData appsAppDataF:appsAppDataFirst){
            if(appsAppDataL.getTrackId().equals(appsAppDataF.getTrackId())){
                appsAppDatas.remove(appsAppDataL);
            }
        }
    }
    return appsAppDatas;
}


3.4.3、List字段去重

// 根据name去重
List<Person> unique = persons.stream().collect(
    Collectors.collectingAndThen(
        Collectors.toCollection(() -> 
                                new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new)
);



// 多个属性同时去重
List<JavaBean> distinctList = javabeans.stream().map(
    item ->(JavaBean)item).collect(
    Collectors.collectingAndThen(
        Collectors.toCollection(
            () -> new TreeSet<>(
                Comparator.comparing(
                    o -> o.getBussContractNo() + ";" + o.getCreditNo()))),
        ArrayList::new));


if(javabeans.size() != distinctList.size()){
    throw new ParameterErrorException("重复提交");
}

3.5、除list集合 list.clear()


/**
5、清除list集合 list.clear();
 */
@Test
public void clear(){
    List<String> list  =   new  ArrayList<String>();
    list.add("aaa");
    list.add("bbb");
    list.add("aaa");
    list.add("aba");
    list.add("aaa");

    list.clear();

    System.out.println( "list.clear list大小 " + list.size());
}

3.6、list 并集addAll,交集retainAll,差集removeAll

	/**
	 * 6、list 并集addAll,交集retainAll,差集removeAll
	 */
	@Test
	public void retainAllAndremoveAll() {

		List<Integer> list = new ArrayList<Integer>();
		List<Integer> list1 = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(1);

		list1.add(2);
		list1.add(3);
		list1.add(4);

		//list和list1的并集:
		//	list.addAll(list1); //1 2 3 2 3 4

		//list和list1的交集:
		//	list.retainAll(list1); // 2 3
		//list和list1的差集:
		list.removeAll(list1);  //1

		for (Integer integer : list) {
			System.out.println(integer);
		}

	}

3.7、 set方法根据索引插入并且替换数据,add是插入

	/**
	 * 7、list set方法根据索引插入并且替换数据
	 */

	@Test
	public void setInsert(){
		String a="A",b="B",c="C",d="D",e="E";
		List<String>list=new ArrayList<>();
		list.add(a);
		list.add(e);
		list.add(d);
		Iterator<String>first=list.iterator();
		System.out.printf("修改前集合中的元素是:");
		while(first.hasNext()){
			System.out.print(first.next()+"    ");
		}

		System.out.println();
	    String temp=	list.set(1, b); //直接替换了上面的索引为1的元素2,并将原来位置上的数据返回
		System.out.println("替换后的元素是"+b+"被替换的是"+temp); //E
		System.out.printf("set修改集合后的元素是:");
		System.out.println(list);


		list.add(2,c);//在索引为2的位置插入了元素c,然后向后移动一位
		System.out.printf("修改集合后的元素是:");
		System.out.println(list);

		// 修改前集合中的元素是:A    E    D
		// 替换后的元素是B被替换的是E
		// set修改集合后的元素是:[A, B, D]
		// 修改集合后的元素是:[A, B, C, D]


	}

3.8、list 数组、逗号字符串中间的转换

@Test
public void cover(){

    String array[] = {"1","2","3"};
    List<String> list ;
    String str ;
    //数组转化为集合
    list =  Arrays.stream(array).collect(Collectors.toList());
    list =  Arrays.asList(array);

    //集合转换为数组
    array =  list.stream().toArray(String[]::new);
    array =  list.toArray(new String[0]);




    //集合转化为逗号的字符串
    str =    list.stream().collect(Collectors.joining(","));
    str = StringUtils.join(list,"," );

    //数组转化为带逗号的字符串
    str = Arrays.stream(array).collect(Collectors.joining(","));




    //逗号字符串转化为数组
    array = str.split(",");

    //逗号字符串转化为集合
    list = Arrays.asList(str.split(",")) ;





	//int 数组转Integer数组
    List<Integer> list = Arrays.stream(nums1).mapToObj(Integer::new).collect(Collectors.toList());
    //List转int数组
	resList.stream().mapToInt(Integer::intValue).toArray()	
    //数组截取
    Arrays.copyOfRange(res, 0, count)
}


3.9、排序:

3.9.1、普通排序:逆序、升序、降序


/**
 *  9.1、 list 排序 :逆序 降序 增序
 */
@Test
public void CollectionsReverse(){

    List<Long> ids  = new ArrayList<>();
    ids.add(1L);
    ids.add(3L);
    ids.add(4l);
    ids.add(8L);
    ids.add(5L);
    ids.add(10L);
    ids.add(10L);
    ids.add(19L);
    ids.add(18L);
    ids.add(14L);
    ids.add(12L);


    //逆序  [12, 14, 18, 19, 10, 10, 5, 8, 4, 3, 1]
    Collections.reverse(ids);
    System.out.println("逆序   "+ids);

    //默认升序 [1, 3, 4, 5, 8, 10, 10, 12, 14, 18, 19]
    Collections.sort(ids);
    System.out.println("默认升序"+ids);

    //降序Collections.reverseOrder() [19, 18, 14, 12, 10, 10, 8, 5, 4, 3, 1]
    Collections.sort(ids, Collections.reverseOrder());
    System.out.println("降序   "+ids);



    Collections.sort(creditBillReceivables, 
                     (o1, o2) -> ((int) (o1.getId() - o2.getId())));

}


3.9.2、对象中多个字段排序

/**
	 *  9.2、 list 排序 :先按照分数排序,如果分数相等了再用分数进行排序
	 */
@Test
public void listObjectSort(){

    List<SortEntry> sortEntries = new ArrayList<SortEntry>();
    sortEntries.add(new SortEntry(23, 100));
    sortEntries.add(new SortEntry(27, 98));
    sortEntries.add(new SortEntry(29, 99));
    sortEntries.add(new SortEntry(29, 98));
    sortEntries.add(new SortEntry(22, 89));
    Collections.sort(sortEntries, (o1, o2) -> {
        int i = o1.getScore() - o2.getScore();  //先按照分数排序
        if(i == 0){
            return o1.getAge() - o2.getAge();  //如果年龄相等了再用分数进行排序
        }
        return i;
    });

    System.out.println(sortEntries);


}




3.10、截取 list.subList

	/**
	 * 10、list截取长度 index包头不包尾巴
	 */
	@Test
	public void listSub(){
		List<Long> list = new ArrayList<>();
		list.add(1L) ;
		list.add(2L) ;
		list.add(3L) ;
		list.add(4L) ;

		List<Long> finalList = list.subList(1, 3);
		System.out.println(finalList); //[2, 3]

	}

3.11、List泛型

Java中的泛型,只在编译阶段有效,Java中编译后的class不会包含泛型信息

反射: 所有反射的操作都是在运行时的,运行时表示已经经过编译了 ,既然为true,就证明了编译之后, 程序会采取去泛型化的措施,也就是说 成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。


@Test
public void test(){
    //1、可以打印
    List list = new ArrayList();
    list.add(1);
    list.add("String");
    Iterator iterator = list.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());//正常打印
    }

    //2、 Java中的泛型,只在编译阶段有效,Java中编译后的class不会包含泛型信息
    ArrayList<String> lista = new ArrayList<>();
    ArrayList listb = new ArrayList();
    Class c1 = lista.getClass();
    Class c2 = listb.getClass();

    System.out.println(lista == listb); //false
    System.out.println(c1 == c2); //true   表示已经经过编译了
    System.out.println(lista.getClass() == listb.getClass()); //true


    //3、反射调用arrylist,说明反射只在编译阶段有效
    ArrayList<String> a = new ArrayList<>();
    a.add("CSDN_SEU_Cavin");
    Class c = a.getClass();
    try{
        Method method = c.getMethod("add",Object.class);
        method.invoke(a,100);
        System.out.println(a);  //[CSDN_SEU_Cavin, 100]
    }catch(Exception e){
        e.printStackTrace();
    }

}


3.12、list.foreach 中断

@Test
public void method(){
    List<Integer> list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);

    list.stream().forEach(item ->{
        // 不可以放入 break;continue ; return相当于continue
        if (item == 2){
            return;
        }
        System.out.println(item);
    });


    // 1
    // 3
}

3.14、new ArrayList<>()

/**
	 * 14、new ArrayList
	 */
	@Test
	public void arrayListTest(){

		Stack<String> stack = new Stack<>();
		stack.push("a");
		stack.push("b");
		stack.push("c");
		List<String> list1 = new ArrayList(stack);
		System.out.println(list1);

		/** Map<String, List<String>> map  */
		Map<String, List<String>> map = new HashMap<>();
		List<String> lista = new ArrayList<>();
		lista.add("a");
		lista.add("b");
		lista.add("c");
		map.put("keyA", lista);
		List<String> listb = new ArrayList<>();
		listb.add("a");
		listb.add("b");
		listb.add("c");
		map.put("keyB", listb);
		List<List<String>> list2 = new ArrayList<>(map.values());
		System.out.println(list2);

	}


[a, b, c]
[[a, b, c], [a, b, c]]

ContactAuthor