前言

博客：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` 变量替换

1.2.1、`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.2.2、`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.2.3、`MessageFormatter.arrayFormat`

@Test
public void test() {
  String msg = "var1:{}, var2:{} 打印:{}";
  Object[] value = new Object[]{"value1", "value2", "result"};
  String message = MessageFormatter.arrayFormat(msg, value).getMessage();
  System.out.println(message);
  // 输出：var1:value1, var2:value2 打印:result
}

1.2.4、`StrUtils.format`

String result = StrUtil.format("Hello, {0}", "world");  
System.out.println(result); // 输出：Hello, world

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 

1.7、`StringUtils.join`

拼接字符串

   @Test
    public void test(){
        String[] strArray  = new String[]{"a", "b", "c"};
        String join = StringUtils.join(strArray);
        System.out.println(join);//abc

        join = StringUtils.join(strArray, "-");
        System.out.println(join);//a-b-c

        List<String> strList = Lists.newArrayList("a", "b", "c");
        join = StringUtils.join(strList, "-");
        System.out.println(join);//a-b-c
    }

1.8、获取指定内存大小的字符串

@Test
public void test_16() throws UnsupportedEncodingException {
  String charsetName = "UTF-8";
  int mSize = 1024 * 1024; //1M
  int kSize = 1024; //1kb
  //制作1024个字节
  StringBuilder sb = new StringBuilder();
  while (sb.toString().getBytes(charsetName).length < kSize){
    sb.append("1");
  }
  String fs = sb.toString();
  System.out.println(fs.length());
  System.out.println(fs.getBytes().length);
}

1.9、字符串拼接

@Test
public void test_17(){
  String str = "ABC".concat("_").concat("Message");
  System.out.println(str);
  //ABC_Message
} 

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

1、Stiring

1.1、 isEmpty、isBlank

1.2、String 变量替换

1.2.1、String.format：%变量替换

1.2.2、MessageFormat.format

1.2.3、MessageFormatter.arrayFormat

1.2.4、StrUtils.format

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

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

1.6、string 和byte数组的转化

1.7、String 和 StringBuffer 之间的转化

1.8、string 可不可以 +

1.9、String …不定参数