java 常用类及方法

-1.Arrays

-1.1. static boolean equals(Object[] a, Object[] a2); 比较两个数组是否相等

  • 利用入参a中的元素的equals()方法比较是否相等，全部都相等返回true，否则返回false
  • 当入参a或者入参a2中有一个为null时，返回false
  • 当入参a与入参a2都为null，返回true

-1.2. static String toString(Object[] a); 数组转中括号字符串

  • 将入参a中各元素的toString()结果中间用逗号隔开首位分别加上中括号左右
  • Arrays.toString(new Integer[]{1, 10, 100}); // "[1, 10, 100]"
  • 如果入参a中只有一个元素则结果中没有逗号
  • Arrays.toString(new Integer[]{1}); // "[1]"
  • 如果入参a中没有元素则只返回中括号
  • Arrays.toString(new Integer[]{}); // "[]"
  • 如果入参为null则返回"null"

-1.3. static List asList(T... a); 将数组转换为List

  • 当入参a是数组则返回的List与入参a占用同一块内存空间，并且返回的List长度无法动态扩容
String[] strings = new String[] {"111", "222", "333"};
List<String> stringList = Arrays.asList(strings); // *
stringList.set(0, "000");
System.out.println(Arrays.toString(strings)); // [000, 222, 333]
System.out.println(stringList); // [000, 222, 333]
stringList.add("444"); //抛异常UnsupportedOperationException
  • 如果想要让数组与转换的结果List分别占用不同的内存空间，则可以把asList()的结果作为List的构造入参
String[] strings = new String[] {"111", "222", "333"};
List<String> stringList = new ArrayList<>(Arrays.asList(strings)); // *
stringList.set(0, "000");
System.out.println(Arrays.toString(strings)); // [111, 222, 333]
System.out.println(stringList); // [000, 222, 333]
  • 当入参a是数组且值为null时，抛异常NullPointerException
  • 当入参是多个参数时会创建一个List将这些参数放入其中然后返回这个List
  • 当入参是多个参数时且其中有一个或多个或全部为null时也可以正常返回
  • List<String> stringList = Arrays.asList("111", null); // [111, null]

0. Integer

0.1. static Integer valueOf(String s); 获取字符串类型的数值转Integer类型的数值

  • 当入参s为null时抛异常NumberFormatException
  • 当入参s中包含非数字字符时抛异常NumberFormatException
  • 当入参s中包含0开头的前缀也可转换成功
  • Integer.valueOf("00123"); // 123
  • 当入参s中的字符串对应的值范围在Integer.MIN_VALUE和Integer.MAX_VALUE之间才能转换成功，否则抛异常NumberFormatException
  • Integer.valueOf("-2147483648"); // -2147483648

0.2. static int parseInt(String s); 获取字符串类型的数值转int类型的数值

  • 当入参s为null时抛异常NumberFormatException
  • 当入参s中包含非数字字符时抛异常NumberFormatException
  • 当入参s中包含0开头的前缀也可转换成功
  • Integer.parseInt("00123"); // 123
  • 当入参s中的字符串对应的值范围在Integer.MIN_VALUE和Integer.MAX_VALUE之间才能转换成功，否则抛异常NumberFormatException
  • Integer.parseInt("2147483647"); // 2147483647

0.3. static int max(int a, int b); 获取入参a和b中的最大值

  • 入参a == 入参b，也可获取最大值

0.4. static int min(int a, int b); 获取入参a和b中的最小值

  • 入参a == 入参b，也可获取最小值

1. String

1.1. String(); 创建一个空字符串

1.2. String(String original); 通过字符串常量创建字符串

1.3. length(); 获取字符串的长度

1.4. charAt(int index); 获取指定下标索引的字符

  • 下标从0开始
  • 当入参下标大于最大下标或小于最小下标时报StringIndexOutOfBoundsException异常

1.5. indexOf(int ch); 获取指定字符第一次出现的位置的下标索引

  • 下标从0开始
  • 当字符串中找不到入参字符时返回-1
  • 入参char会自动类型转换为int

1.6. indexOf(String s); 获取指定字符串第一次出现的位置的首字符下标索引

  • 下标从0开始
  • 当入参是空字符串""时返回0，
  • 当入参是null时报异常NullPointerException
  • 当前字符串中找不到入参字符串s时返回-1，
  • 入参字符串去匹配时必须全部匹配上才算找到
  • "abcdabcd".indexOf("cd") == 2;

  • "abcdabcd".indexOf("cde") == -1;

1.7. lastIndexOf(int ch); 获取指定字符最后一次出现的位置的下标索引

  • 下标从0开始
  • 当字符串中找不到入参字符时返回-1
  • 入参char会根据字符集自动类型转换为int

1.8. lastIndexOf(String str); 获取指定字符串最后一次出现的位置的首字符下标索引

  • 下标从0开始
  • 当入参是空字符串""时返回最大下标+1
  • 当入参是null时报异常NullPointerException
  • 当字符串中找不到入参字符串时返回-1
  • 入参字符串去匹配时必须全部匹配上才算找到
  • "abcdabcd".indexOf("cd") == 6;

  • "abcdabcd".indexOf("cde") == -1;

1.9. substring(int beginIndex); 获取从指定下标位置开始一直到末尾的字符构成的子串

  • 下标从0开始
  • 子串中包含指定下标位置的字符也包含末尾字符
  • 当入参下标等于最大下标+1获取空串
  • 当入参下标大于最大下标+1或小于最小下标时报异常StringIndexOutOfBoundsException
  • "abcdabcd".substring(3) == "dabcd";

  • "abcdabcd".substring(7) == "d";

  • "abcdabcd".substring(8) == "";

1.10. substring(int beginIndex, int endIndex); 获取从指定开始下标位置开始一直到指定结束下标位置的字符构成的子串

  • 下标从0开始
  • 子串中包含指定开始下标位置的字符，不包含指定结束下标位置的字符
  • 当入参开始下标或入参结束下标中有一个大于最大下标+1或小于最小下标时报异常StringIndexOutOfBoundsException
  • "abcdabcd".substring(3,5) == "da"; 

  • "abcdabcd".substring(7,7) == "";

  • "abcdabcd".substring(7,8) == "d";

  • "abcdabcd".substring(8,8) == "";

1.11. toLowerCase(); 获取小写字符串

  • 不会改变原有字符串，只会获取一个新结果
  • 当字符串中包含非英文字符时会将非英文的字符原样输出
  • "abCdabcD".toLowerCase() == "abcdabcd"; 

  • "abCd%abcD".toLowerCase() == "abcd%abcd";

1.12. toUpperCase(); 获取大写字符串

  • 不会改变原有字符串，只会获取一个新结果
  • 当字符串中包含非英文字符时会将非英文的字符原样输出
  • "abCdabcD".toLowerCase() == "ABCDABCD"; 

  • "abCd%abcD".toLowerCase() == "ABCD%ABCD";

1.13. concat(String str); 获取拼接后的新字符串

  • 不会改变原有字符串，只会获取一个新结果
  • 当入参是null时报异常NullPointerException
  • "abcdabcd".concat("EE") == "abcdabcdEE";

1.14. replace(char oldChar,char newChar); 获取将字符串中所有oldChar替换成newChar的新字符串

  • 不会改变原有字符串，只会获取一个新结果
  • "abcdabcd".replace('b','B') == "aBcdaBcd";

1.15. replace(CharSequence target, CharSequence replacement); 获取将字符串中所有target替换成replacement的新字符串

  • 不会改变原有字符串，只会获取一个新结果
  • CharSequence是String的父接口
  • "abcdabcd".replace("bc","BC") == "aBCdaBCd";

1.16. replaceAll(String regex, String replacement); 获取将字符串中所有能匹配正则表达式regex的子串替换成replacement的新字符串

  • 不会改变原有字符串，只会获取一个新结果

1.17. replaceFirstString regex, String replacement); 获取将字符串中能匹配正则表达式regex的第一个子串替换成replacement的新字符串

  • 不会改变原有字符串，只会获取一个新结果

1.18. trim(); 获取字符串去除两边空格后的新字符串

  • 不会改变原有字符串，只会获取一个新结果
  • 只会去除两边的空格，不会去除中间的空格
  • " a bcdabcd ".trim() == "a bcdabcd";

1.19. isEmpty(); 判断字符串是否为空,其实就是判断字符串长度是否为0

1.20. equals(Object anObject); 比较两个字符串是否相等

  • 当入参对象不是String的实例对象时返回false
  • 当入参是null时返回false
  • "abcdabcd".equals("abcdabcd") == true;

  • "abcdabcd".equals(new ArrayList()) == false;

  • "abcdabcd".equals(null) == false;

1.21. equalsIgnoreCase(String anotherString); 忽略大小写比较两个字符串是否相等

  • 当入参是null时返回false
  • "abcdabcd".equalsIgnoreCase("abCdaBcd") == true;

  • "abcdabcd".equalsIgnoreCase(null) == false;

1.22. contains(CharSequence s); 判断是否包含指定字符串

  • 入参字符串s去匹配时必须全部匹配上才算包含,也就是入参字符串s中的部分字符在当前字符串中匹配上不算包含
  • CharSequence是String的父接口
  • 当入参是null时报异常NullPointerException
  • "abcdabcd".contains("da") == true;

  • "abcdabcd".contains("dac") == false;

1.22. startsWith(String prefix); 判断是否以指定的字符串开头

  • 入参字符串去与开头匹配时必须全部匹配上才算,也就是入参字符串prefix中的部分字符在当前字符串中的开头匹配上不算包含
  • 当入参是null时报异常NullPointerException
  • "abcdabcd".startsWith("ab") == true;

  • "abcdabcd".startsWith("abd") == false;

1.23. endsWith(String suffix); 判断是否以指定的字符串结尾

  • 入参字符串去与结尾匹配时必须全部匹配上才算,也就是入参字符串suffix中的部分字符在当前字符串中的结尾匹配上不算包含
  • 当入参是null时报异常NullPointerException
  • "abcdabcd".startsWith("cd") == true;

  • "abcdabcd".contains("acd") == false;

1.24. matches(String regex); 判断当前字符串是否能匹配给定的正则表达式规则

1.25. int compareTo(String s); 字典比较，如果前面值小于后面值返回负数，否则返回正数，相等返回0

  • 先比较第一个元素，如果相等再比较第二个元素...如果相等比较第n个元素...直到比较到不相等的元素，返回元素之间的差值
  • 如果比较的两个字符串有以头部开始的包含关系，返回的值是它们长度的差值
  • "abc".compareTo("ade") == -2;

  • "abc".compareTo("ab") == 1;

1.26. int compareToIgnoreCase(String s); 忽略大小写字典比较

  • 其他内容参考int compareTo(String s)

1.27. static String join(CharSequence delimiter, CharSequence... elements); 多字符串以指定字符串拼接

  • 不会改变原有字符串，只会获取一个新结果
  • String.join("||", "abcd","efgh","ijk") == "abcd||efgh||ijk"
  • String.join("||", "abcd") == "abcd"
  • String.join("||", "abcd","","ijk") == "abcd||||ijk"
  • String.join("||", "abcd",null,"ijk") == "abcd||null||ijk"
  • String.join("", "abcd","efgh","ijk") == "abcdefghijk"
  • String.join(null, "abcd","efgh","ijk") 抛异常NullPointerException

1.28. split(String regex); 获取以正则表达式regex匹配到的子串作为分界对字符串进行拆分所得的字符串数组

  • 不会改变原有字符串，只会获取一个新结果
  • 作为分界的子串并不会包含在结果中
  • "abcdabcd".split("b") == ["a","cda","cd"];

  • "abcdabcd".split("a") == ["","bcd","bcd"]; 

  • "abcdabcd".split("d") == ["abc","abc"];

1.29. split(String regex, int limit); 获取以正则表达式regex匹配到的子串作为分界对字符串进行拆分所得的字符串数组

  • limit代表结果的数量，当limit==1时表示结果数组中只有一个结果,即无分界串
  • 当limit==2时表示结果数组中只有两个结果,即只将regex匹配到的第一个子串作为分界串
  • 当limit>=根据regex最大可分数量,即将regex匹配到的全部子串作为分界串
  • 当limit<=0,即将regex匹配到的全部子串作为分界串
  • "abcdabcd".split("b",1) == ["abcdabcd"];

  • "abcdabcd".split("b",2) == ["a","cdabcd"];

  • "abcdabcd".split("b",3) == ["a","cda","cd"];

  • "abcdabcd".split("b",4) == ["a","cda","cd"];

  • "abcdabcd".split("b",0) == ["a","cda","cd"];

  • "abcdabcd".split("b",-1) == ["a","cda","cd"];

2. Date

2.1. Date(); 创建当前日期时间

2.2. Date(int year, int month, int date, int hrs, int min, int sec); 创建指定日期时间，

  • 指定时间由入参year(年) month(月) date(日) hrs(时) min(分) sec(秒) 指定, 默认毫秒值为0

2.3. Date(long date); 创建指定日期时间，

  • 入参date为指定日期时间到格林威治起始时间(1970-1-1 8:0:0)的毫秒值

2.4. setTime(long time); 设置为指定日期时间，

  • 入参time为指定日期时间到格林威治起始时间(1970-1-1 8:0:0)的毫秒值

2.5. getTime(); 获取指定日期时间到格林威治起始时间(1970-1-1 8:0:0)的毫秒值，

  • 指定时间是new Date() 或 setTime()设置好的

3. SimpleDateFormat

3.1. SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); 创建一个指定日期格式的转换器

3.2. format(Date date); 获取入参date转为指定格式后的日期时间字符串

  • 仅获取新结果，并不改变原有数据

3.3. parse(String source); 获取指定格式的时间日期入参source转为Date的结果,

  • 仅获取新结果，并不改变原有数据
  • sourse的格式要符合指定的格式
  • 使用此方法要处理ParseException异常

4. Calendar

4.1. Calender.getInstance(); 创建当前日期时间

  • 返回Calender对象

4.2. void set(int year, int month, int date, int hourOfDay, int minute, int second); 设置指定日期时间

  • 指定时间由入参year(年) month(月) date(日) hourOfDay(时) minute(分) second(秒) 指定, 默认毫秒值为0

4.3. void setTime(Date date); 根据入参date设置指定日期时间

4.4. void setTimeInMillis(long millis); 根据入参millis设定指定日期时间

  • 入参millis是时间戳

4.5. Date getTime(); 获取指定日期时间

  • 指定的日期时间是Calender.getInstance()或set()或setTime()或setTimeInMillis()已设置好的

4.6. long getTimeInMillis(); 获取指定日期时间

  • 返回值是时间戳

4.7. get(int field); 根据入参field指定获取日期时间的某一属性值

  • 入参field = Calendar.YEAR(年)/Calendar.MONTH(月)/Calendar.DAY_OF_MONTH(日)/Calendar.HOUR_OF_DAY(时)/Calendar.MINUTE(分)/Calendar.SECOND(秒)/Calendar.MILLISECOND(毫秒)...

4.8. void add(int field, int amount); 将指定的日期时间的某一属性（由入参field指定）的值加上一个值（入参amount）

  • 时间运算
  • 会直接对源日期时间进行修改
  • 入参field = Calendar.YEAR(年)/Calendar.MONTH(月)/Calendar.DAY_OF_MONTH(日)/Calendar.HOUR_OF_DAY(时)/Calendar.MINUTE(分)/Calendar.SECOND(秒)/Calendar.MILLISECOND(毫秒)...
  • 入参amount可以填正数或负数

4.9. boolean before(Object when); 判断指定日期时间是否在入参日期时间when之前

  • 时间运算
  • 指定日期时间在入参时间when之前返回true，否则返回false

4.10. boolean after(Object when); 判断指定日期时间是否在入参日期时间when之后

  • 时间运算
  • 指定日期时间在入参时间when之后返回true，否则返回false

4.11. int compareTo(Calendar anotherCalendar); 比较指定日期时间与入参日期时间anotherCalendar的大小

  • 时间运算
  • 指定日期时间在入参日期时间anotherCalendar之前返回-1
  • 指定日期时间在入参日期时间anotherCalendar之后返回1
  • 指定日期时间与入参日期时间anotherCalendar相同返回0

5. ArrayList<E>

  • ArrayList 有序（有先后顺序，无大小顺序，允许重复元素）
  • HashSet 无序 （无先后顺序，无大小顺序，不允许重复元素）

5.1. int size(); 获取当前集合中元素的个数

5.2. boolean isEmpty(); 用于判断当前集合中元素的个数是否为0

  • 元素个数为0返回true，否则返回false

5.3. int indexOf(Object o); 获取与入参元素o相同的元素在集合中第一次出现位置的下标索引

  • 如果当前集合中不存在与元素o相同的元素返回-1
  • 通过元素o的equals()判断是否相同

5.4. int lastIndexOf(Object o); 获取与入参元素o相同的元素在集合中最后一次出现位置的下标索引

  • 如果当前集合中不存在与元素o相同的元素返回-1
  • 通过元素o的equals()判断是否相同

5.5. E set(int index, E element); 用入参元素element替换当前集合中下标index处的元素

  • 替换成功，返回被替换的元素

5.6. E get(int index); 获取下标index处的元素

  • 要求index<size(),否则报异常IndexOutOfBoundsException

5.7. boolean add(E e); 将入参元素e插入集合尾部中

  • 插入成功默认返回true

5.8. void add(int index, E element); 将元素element插入到当前集合中下标index的位置

  • 当index<=size()且集合中下标index处已有元素再插入元素时，会先将index及之后位置处的元素向后移动一位然后在index处放入新元素
  • 当index>size()或index<0时报异常IndexOutOfBoundsException

5.9. boolean addAll(Collection<? extends E> c); 将入参集合c中的元素插入集合尾部中

5.10. boolean addAll(int index, Collection<? extends E> c); 将集合c中的元素插入到当前集合中下标index的位置

  • 当index<=size()且集合中下标index处已有元素再插入元素时，会先将index及之后位置处的元素向后移动c.size()位然后将c中的元素放入从index处开始的位置
  • 当index>size()或index<0时报异常IndexOutOfBoundsException

5.11. E remove(int index); 将下标index处的元素从当前集合移除

  • 移除成功返回移除掉的元素
  • 要求index<size()，否则报异常IndexOutOfBoundsException

5.12. boolean remove(Object o); 删除与入参元素o相同的元素

  • 删除成功返回true，删除失败（没有相同元素）返回false
  • 通过元素o的equals()判断元素是否相同

5.13. boolean removeAll(Collection<?> c); 删除当前集合中与入参集合c中的元素相同的元素

  • 删除成功返回true，否则（入参集合c中没有与当前集合中相同的元素）返回false
  • 通过集合c中各元素的equals()判断是否相同

5.14. void clear(); 删除集合中所有元素

  • 不会将集合变为null，只会将集合中元素个数变为0

5.15. boolean contains(Object o); 判断集合中是否包含与入参元素o相同的元素

  • 包含返回true，否则返回false
  • 通过元素o的equals()判断是否相同

5.16. boolean containsAll(Collection<?> c); 判断入参集合c中的所有元素是否都能在当前集合中找到相同的

  • 全部都能找到返回true，否则（c中有在当前集合中找不到的元素）返回false
  • 通过集合c中各元素的equals()判断是否相同，从而判断是否找到

5.17. boolean retainAll(Collection<?> c); 将当前集合和入参集合c的交集并保留到当前集合中

  • 保存成功当前集合中仅存在交集元素并返回true，否则（没有交集）当前集合中元素不变并返回false
  • 通过集合c中各元素的equals()判断是否相同

5.18. List subList(int fromIndex, int toIndex); 获取当前集合中从下标fromIndex(包含)到下标toIndex(不包含)之间的元素组成的新List

  • 要求fromIndex<=size()且toIndex<=size(),否则报异常IndexOutOfBoundsException
  • 要求fromIndex<=toIndex,否则报异常IllegalArgumentException
  • 当fromIndex==toIndex，返回空List（size() == 0）
  • 返回的新List和当前集合共用同一块内存区域
  • ArrayList<String> arrayList = new ArrayList();
    arrayList.add("aaa"); arrayList.add("bbb"); arrayList.add("ccc"); arrayList.add("ddd");
    List<String> subList = arrayList.subList(1, 3);
    subList.set(0, "111");
    subList.add("222");
    System.out.println(subList); //[111, ccc, 222]
    System.out.println(arrayList); //[aaa, 111, ccc, 222, ddd]

5.19. Object[] toArray(); 获取当前集合转为数组的结果

  • 当前集合不变，只是获取了一个新结果

5.20. Iterator iterator(); 获取当前集合的迭代器

  • 用此迭代器可以遍历当前集合的元素

6. LinkedList<E>

6.1. int size(); 获取当前集合中元素的个数

6.2. boolean isEmpty(); 用于判断当前集合中元素的个数是否为0

  • 元素个数为0返回true，否则返回false

6.3. int indexOf(Object o); 获取与入参元素o相同的元素在集合中第一次出现位置的下标索引

  • 如果当前集合中不存在与元素o相同的元素返回-1
  • 通过元素o的equals()判断是否相同

6.4. int lastIndexOf(Object o); 获取与入参元素o相同的元素在集合中最后一次出现位置的下标索引

  • 如果当前集合中不存在与元素o相同的元素返回-1
  • 通过元素o的equals()判断是否相同

6.5. E set(int index, E element); 用入参元素element替换当前集合中下标index处的元素

  • 替换成功，返回被替换的元素

6.6. E get(int index); 获取下标index处的元素

  • 要求index<size(),否则报异常IndexOutOfBoundsException

6.7. E element(); 获取当前集合中的第一个元素

  • 如果集合为空（size()==0），报异常NoSuchElementException

6.8. E getFirst(); 获取当前集合中的第一个元素

  • 如果集合为空（size()==0），报异常NoSuchElementException

6.9. E getLast(); 获取当前集合中的最后一个元素

  • 如果集合为空（size()==0），报异常NoSuchElementException

6.10. E peek(); 获取当前集合中的第一个元素

  • 如果集合为空（size()==0），则返回null

6.11. E peekFirst(); 获取当前集合中的第一个元素

  • 如果集合为空（size()==0），则返回null

6.12. E peekLast(); 获取当前集合中的最后一个元素

  • 如果集合为空（size()==0），则返回null

6.13. boolean add(E e); 将入参元素e插入到当前集合的结尾

  • 插入成功默认返回true

6.14. void add(int index, E element); 将元素element插入到当前集合中下标index的位置

  • 双向链表结构插入删除效率高
  • 要求index <= size(), 否则报异常IndexOutOfBoundsException

6.15. void addFirst(E e); 将入参元素e插入到当前集合的开头

6.16. void addLast(E e); 将入参元素e插入到当前集合的结尾

6.17. boolean offer(E e); 将入参元素e插入到当前集合的结尾

  • 插入成功默认返回true

6.18. boolean offerFirst(E e); 将入参元素e插入到当前集合的开头

  • 插入成功默认返回true

6.19. boolean offerLast(E e); 将入参元素e插入到当前集合的结尾

  • 插入成功默认返回true

6.19. boolean addAll(Collection<? extends E> c); 将入参集合c中的元素插入集合尾部中

6.19. boolean addAll(int index, Collection<? extends E> c); 将集合c中的元素插入到当前集合中下标index的位置

  • 当index<=size()且集合中下标index处已有元素再插入元素时，会先将index及之后位置处的元素从链表断开然后将c中的元素放入连接到断开的位置，最后将断开的元素链连接到尾部
  • 当index>size()或index<0时报异常IndexOutOfBoundsException

6.20. E remove(int index); 将下标index处的元素从当前集合中移除

  • 移除成功返回移除掉的元素
  • 要求index<size()，否则报异常IndexOutOfBoundsException

6.21. boolean remove(Object o)；删除与入参元素o相同的元素

  • 删除成功返回true，删除失败（没有相同元素）返回false
  • 通过元素o的equals()判断元素是否相同

6.22. E removeFirst(); 移除集合中的第一个元素

  • 移除成功返回被移除掉的元素
  • 如果集合为空（size()==0），报异常NoSuchElementException

6.23. E removeLast(); 移除集合中的最后一个元素

  • 移除成功返回被移除掉的元素
  • 如果集合为空（size()==0），报异常NoSuchElementException

6.24. E poll(); 移除集合中的第一个元素

  • 移除成功返回被移除掉的元素
  • 如果集合为空（size()==0），则返回null

6.25. E pollFirst(); 移除集合中的第一个元素

  • 移除成功返回被移除掉的元素
  • 如果集合为空（size()==0），则返回null

6.26. E pollLast(); 移除集合中的最后一个元素；

  • 移除成功返回被移除掉的元素
  • 如果集合为空（size()==0），则返回null

6.27. boolean removeAll(Collection<?> c); 删除当前集合中与入参集合c中的元素相同的元素

  • 删除成功返回true，否则（入参集合c中没有与当前集合中相同的元素）返回false
  • 通过集合c中各元素的equals()判断是否相同

6.28. void clear(); 删除集合中所有元素

  • 并不会将集合变为null，只会将集合中元素个数变为0

6.29. boolean contains(Object o); 判断集合中是否包含与入参元素o相同的元素

  • 包含返回true，否则返回false
  • 通过元素o的equals()判断是否相同

6.30. boolean containsAll(Collection<?> c); 判断入参集合c中的所有元素是否都能在当前集合中找到相同的

  • 全部都能找到返回true，否则（c中有在当前集合中找不到的元素）返回false
  • 通过集合c中各元素的equals()判断是否相同，从而判断是否找到

6.31. boolean retainAll(Collection<?> c); 将当前集合和入参集合c的交集并保留到当前集合中

  • 保存成功当前集合中仅存在交集元素并返回true，否则（没有交集）当前集合中元素不变并返回false
  • 通过集合c中各元素的equals()判断是否相同

6.32. List subList(int fromIndex, int toIndex); 获取当前集合中从下标fromIndex(包含)到下标toIndex(不包含)之间的元素组成的新List

  • 要求fromIndex<=size()且toIndex<=size(),否则报异常IndexOutOfBoundsException
  • 要求fromIndex<=toIndex,否则报异常IllegalArgumentException
  • 当fromIndex==toIndex，返回空List（size() == 0）
  • 返回的新List和当前集合共用同一块内存区域

6.33. Object[] toArray(); 获取当前集合转为数组的结果

  • 当前集合不变，只是获取了一个新结果

6.34. Iterator iterator(); 获取当前集合的迭代器

  • 用此迭代器可以遍历当前集合的元素

7. Vector<E>

7.1. 方法名称和参数与ArrayList里的一样
7.2. 方法都是synchronized方法

8. HashSet<E>

8.1. int size(); 获取当前集合中元素的个数

8.2. boolean isEmpty(); 用于判断当前集合中元素的个数是否为0

  • 元素个数为0返回true，否则返回false

8.3. boolean add(E e); 将入参元素e插入集合中。

  • 当前集合中有元素与入参元素e相同时插入失败并返回false。否则插入成功并返回true;
  • 利用哈希表判断是否相同（利用hashCode()的结果判断是否相同。如果hashCode()的结果不同表示没有不重复。如果hashCode()的结果相同需要再调用equals()来决定是否重复）

8.4. boolean addAll(Collection<? extends E> c); 将入参集合c中的元素插入集合中。

  • 当入参集合c中有部分元素与当前集合中元素相同时，相同的部分插入失败，不同的部分插入成功，返回true。
  • 当入参当入参集合c中全部元素都与当前集合中元素相同时，插入失败，返回false。
  • 当入参当入参集合c中没有元素与当前集合中元素相同时，插入成功，返回true。
  • 利用哈希表判断是否相同

8.5. boolean remove(Object o); 删除与入参元素o相同的元素，

  • 删除成功返回true，删除失败（没有相同元素）返回false
  • 利用哈希表判断是否相同

8.6. boolean removeAll(Collection<?> c); 删除与入参集合c中的元素相同的元素

  • 删除成功返回true，否则（入参集合c中没有与当前集合中相同的元素）返回false。
  • 利用哈希表判断是否相同

8.7. void clear(); 删除集合中所有元素

  • 并不会将集合变为null，只会将集合中的元素个数变为0

8.8. boolean contains(Object o); 判断集合中是否包含与入参元素o相同的元素

  • 包含返回true，否则返回false
  • 利用哈希表判断是否相同

8.9. boolean containsAll(Collection<?> c); 判断入参集合c中的所有元素是否都能在当前集合中找到相同的。

  • 全部都能找到返回true，否则（c中有在当前集合中找不到的元素）返回false
  • 利用哈希表判断是否相同

8.10. boolean retainAll(Collection<?> c);将当前集合和入参集合c的交集并保留到当前集合中

  • 保存成功当前集合中仅存在交集元素并返回true，否则（没有交集）当前集合中元素不变并返回false
  • 利用哈希表判断是否相同

8.11. Object[] toArray(); 获取当前集合转为数组的结果

  • 当前集合不变，只是获取了一个新结果

8.12. Iterator iterator(); 获取当前集合的迭代器

  • 用此迭代器可以遍历当前集合的元素

9. TreeSet<E>

9.1. int size(); 获取当前集合中元素的个数

9.2. boolean isEmpty(); 用于判断当前集合中元素的个数是否为0

  • 元素个数为0返回true，否则返回false

9.3. E ceiling(E e); 获取当前集合中大于或等于入参e的最小元素

  • 如果没有这样的元素返回null

9.4. E floor(E e); 返回当前集合中小于或等于入参e的最大元素

  • 如果没有这样的元素返回null

9.5. E higher(E e); 获取当前集合中大于入参e的最小元素

  • 如果没有这样的元素返回null

9.6. E lower(E e); 返回当前集合中小于入参e的最大元素

  • 如果没有这样的元素返回null

9.7. boolean add(E e); 将入参元素e插入集合中。

  • 当前集合中有元素与入参元素e相同时插入失败并返回false。否则插入成功并返回true;
  • 可利用实现Comparable接口的入参元素c中重写的compareTo(T o)方法判断大小及相同（-1，0， 1）
  • 可利用实现Comparator接口且作为TreeSet构造入参的自定义比较器对象中重写的compare()方法判断大小及相同（-1，0， 1）

9.8. boolean addAll(Collection<? extends E> c); 将入参集合c中的元素插入集合中。

  • 当入参集合c中有部分元素与当前集合中元素相同时，相同的部分插入失败，不同的部分插入成功，返回true。
  • 当入参当入参集合c中全部元素都与当前集合中元素相同时，插入失败，返回false。
  • 当入参当入参集合c中没有元素与当前集合中元素相同时，插入成功，返回true。

9.9. boolean remove(Object o); 删除与入参元素o相同的元素，

  • 删除成功返回true，删除失败（没有相同元素）返回false

9.10. boolean removeAll(Collection<?> c); 删除与入参集合c中的元素相同的元素

  • 删除成功返回true，否则（入参集合c中没有与当前集合中相同的元素）返回false

9.11. void clear(); 删除集合中所有元素

  • 并不会将集合变为null，只会将集合中的元素个数变为0

9.12. boolean contains(Object o); 判断集合中是否包含与入参元素o相同的元素

  • 包含返回true，否则返回false

9.13. boolean containsAll(Collection<?> c); 判断入参集合c中的所有元素是否都能在当前集合中找到相同的。

  • 全部都能找到返回true，否则（c中有在当前集合中找不到的元素）返回false

9.14. boolean retainAll(Collection<?> c);将当前集合和入参集合c的交集并保留到当前集合中

  • 保存成功当前集合中仅存在交集元素并返回true，否则（没有交集）当前集合中元素不变并返回false

9.15. Object[] toArray(); 获取当前集合转为数组的结果

  • 当前集合不变，只是获取了一个新结果

9.16. Iterator iterator(); 获取当前集合的迭代器

  • 用此迭代器可以遍历当前集合的元素

10. HashMap<K,V>

10.1. int size(); 获取当前集合中键值对的个数

10.2. boolean isEmpty(); 用于判断当前集合中键值对的个数是否为0

  • 键值对个数为0返回true，否则返回false

10.3. V get(Object key); 获取入参key相同的键对应的值，

  • 如果没有与入参key相同的键返回null
  • 集合中的键利用哈希表判断是否相同（利用hashCode()的结果判断是否相同。如果hashCode()的结果不同表示没有不重复。如果hashCode()的结果相同需要再调用equals()来决定是否重复）

10.4. V put(K key, V value); 将入参键值对(key:value)放入Map集合中

  • 如果入参key与集合中所有键值对的键都不同，则将入参键值对(key:value)放入Map集合中
  • 如果入参key与集合中某一键值对的键相同，则替换集合中对应键的值为新值(入参value)并且将旧值返回
  • 集合中的键利用哈希表判断是否相同（利用hashCode()的结果判断是否相同。如果hashCode()的结果不同表示没有不重复。如果hashCode()的结果相同需要再调用equals()来决定是否重复）

10.5. void putAll(Map<? extends K, ? extends V> m); 将入参集合m中的各键值对放入当前集合中

  • 注意去重效应

10.6. V remove(Object key); 将与入参key有相同键的键值对从Map集合中删除

  • 删除成功返回被删除的键值对的键

10.7. boolean remove(Object key, Object value); 将当前集合中键与入参key相同且值与入参value相同的键值对删除

  • 集合中的键利用哈希表判断是否相同
  • 集合中的值是否相同用equals

10.8. V replace(K key, V value); 将与入参key相同的键值对中的值替换成入参value

  • 替换成功返回被替换的值

10.9. boolean replace(K key, V oldValue, V newValue); 将与入参键值对key-oldValue相同的键值对的值替换为newValue

  • 替换成功返回true

10.10. void clear(); 删除集合中所有键值对

  • 并不会将集合变为null只会将元素个数变为0

10.11. boolean containsKey(Object key); 判断当前Map集合中是否包含键与入参key相同的键值对

  • 利用哈希表判断是否相同

10.12. boolean containsValue(Object value); 判断当前Map集合中是否包含值与入参value相同的键值对

  • 利用equals方法比较是否相同

10.13. Set<Map.Entry<K,V>> entrySet(); 将Map集合中的键值对(Map.Entry)组成Set集合返回

10.14. Set keySet(); 将Map集合中的所有键组成Set集合返回

10.15. Collection values(); 将Map集合中所有值组成Collection集合返回

11. TreeMap<K,V>

11.1. int size(); 获取当前集合中键值对的个数

11.2. boolean isEmpty(); 用于判断当前集合中键值对的个数是否为0

11.3. V get(Object key); 获取与入参key相同的键对应的值

  • 如果当前集合中没有与入参key相同的键，则返回null
  • 如果是用TreeMap()创建的集合，则利用入参对象key的int compareTo(Integer anotherInteger)方法判断键是否相同
  • 如果是用TreeMap(Comparator<? super K> comparator)创建的集合，则利用入参对象comparator的int compare(Integer o1, Integer o2)方法判断键是否相同

11.4. V put(K key, V value); 将入参键值对(key-value)对放入Map集合中

  • 如果入参key与集合中某键值对的键相同，则替换集合中该键对应的值为新值(即入参value)，并且将旧值返回
  • 如果是用TreeMap()创建的集合，则利用入参对象key的int compareTo(Integer anotherInteger)方法判断集合新入键值对的存放位置以及是否存储（多次调用put方法的入参对象key的int compareTo(Integer anotherInteger)方法，compareTo方法入参anotherInteger依次为集合中已有元素。如果返回1代表集合中新入元素应放入入参anotherInteger元素的后面，如果返回-1代表集合中新入元素应放入入参anotherInteger元素的前面，如果返回0代表集合中新入的元素重复不会存储）
  • 如果是用TreeMap(Comparator<? super K> comparator)创建的集合，则利用入参对象comparator的int compare(Integer o1, Integer o2)方法判断集合新入键值对的存放位置以及是否存储（多次入参比较器对象comparator的int compare(Integer o1, Integer o2)方法，compare方法入参o1为put方法的入参，compare方法入参o2依次为集合中已有的元素。如果返回1代表集合中新入的元素o1应放入入参元素o2的后面，如果返回-1代表集合中新入的元素o1应放入入参元素o2的前面，如果返回0代表集合中新入的元素o1重复不会存储）

11.5. void putAll(Map<? extends K, ? extends V> m); 将入参集合m中的各键值对放入当前集合中

  • 当入参集合m中有部分键值对的键与当前集合中键值对的键相同，则效果改为相同部分的键值对由插入键值对改为修改键值对的值
  • 利用compareTo方法比较是否相同

11.6. V remove(Object key); 将与入参key有相同键的键值对从Map集合中删除

  • 利用compareTo方法比较是否相同

11.7. boolean remove(Object key, Object value); 将当前集合中键与入参key相同且值与入参value相同的键值对删除

  • 键是否相同用compareTo方法，值是否相同用equals

11.8. V replace(K key, V value); 替换指定key对应的value值，返回旧值

  • 当前集合中不存在与key有相同键的键值对时返回null

11.9. boolean replace(K key, V oldValue, V newValue)：当指定key的对应的value为指定值时，替换该值为新值。

  • 键是否相同用compareTo方法，值是否相同用equals

11.10. void clear(); 删除集合中所有键值对

  • 并不会将集合变为null只会将元素个数变为0

11.11. boolean containsKey(Object key); 判断当前Map集合中是否包含键与入参key相同的键值对

11.12. boolean containsValue(Object value); 判断当前Map集合中是否包含值与入参value相对的键值对

11.13. Set<Map.Entry<K,V>> entrySet(); 将Map集合中的键值对(Map.Entry)组成Set集合返回

11.14. Set keySet(); 将Map集合中的所有键组成Set集合返回

11.15. Collection values(); 将Map集合中所有值组成Collection集合返回

11.16. K firstKey(); 获取当前集合中第一个键值对的键

11.17. K lastKey(); 获取当前集合中最后一个键值对的键

11.18. K ceilingKey(K key); 获取当前集合中键大于或等于入参key的最小键。

  • 如果没有这样的键返回null

11.19. K floorKey(K key); 获取当前集合中键小于或等于入参key的最小键。

  • 如果没有这样的键返回null

11.20. K higherKey(K key); 获取当前集合中键严格大于入参key的最小键。

  • 如果没有这样的键返回null

11.21. K lowerKey(K key); 获取当前集合中键严格小于入参key的最小键。

  • 如果没有这样的键返回null

11.22. Map.Entry<K,V> firstEntry(); 获取当前集合中第一个键值对

11.23. Map.Entry<K,V> lastEntry(); 获取当前集合中最后一个键值对

11.24. Map.Entry<K,V> ceilingEntry(K key); 获取当前集合中键大于或等于入参key的最小键对应的键值对。

  • 如果没有这样的键值对返回null

11.25. Map.Entry<K,V> floorEntry(K key); 获取当前集合中键小于或等于入参key的最小键对应的键值对。

  • 如果没有这样的键值对返回null

11.26. Map.Entry<K,V> higherEntry(K key); 获取当前集合中键严格大于入参key的最小键对应的键值对。

  • 如果没有这样的键值对返回null

11.27. Map.Entry<K,V> lowerEntry(K key); 获取当前集合中键严格小于入参key的最小键对应的键值对。

  • 如果没有这样的键值对返回null

11.28. SortedMap<K,V> tailMap(K fromKey); 获取当前集合中键大于或等于入参fromKey的所有键对应的键值对组成的集合。

  • 如果没有这样的键值对返回空集合(size()==0)

11.29. SortedMap<K,V> headMap(K toKey); 获取当前集合中键严格小于入参toKey的所有键对应的键值对组成的集合。

  • 如果没有这样的键值对返回空集合(size()==0)

11.30. SortedMap<K, V> subMap(K fromKey, K toKey); 获取当前集合中键大于或等于入参fromKey且严格小于入参toKey的所有键对应的键值对组成的集合。

  • 如果没有这样的键值对返回空集合(size()==0)

12. Collections

12.1. public static boolean addAll(Collection<? super T> c, T... elements); 将入参各元素elements放入入参集合c中

12.2. public static <T extends Comparable<? super T>> void sort(List list); 对入参集合list中实现Comparable接口并重写int compareTo(T o)方法的元素按照int compareTo(T o)的大小顺序进行排序

12.3. public static void sort(List list, Comparator<? super T> c); 对入参集合list中的元素按照入参c中的int compare(T o1, T o2)方法的大小顺序进行排序

  • 入参c是实现Comparator接口并重写int compare(T o1, T o2)方法的对象

12.4. public static int binarySearch(List<? extends Comparable<? super T>> list, T key); 获取入参集合list中与入参key相同的元素的下标

  • 要求入参list中的元素必须有大小顺序或者已经完成大小排序

12.5. public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll); 获取入参集合coll中最大的元素

  • 通过集合coll中各元素实现Comparable接口后重写的int compareTo(T o)方法判断大小

12.6. public static T max(Collection<? extends T> coll, Comparator<? super T> comp); 获取入参集合coll中最大的元素

  • 通过入参comp对象实现的Comparator接口重写的int compare(T o1, T o2)方法判断大小

12.7. public static boolean replaceAll(List list, T oldVal, T newVal); 将入参集合list中与入参oldVal相同的元素全部替换成newVal

  • 通过list中各对象的equals()方法比较是否相同
  • 如果没有与oldVal相同的元素返回false否则返回true

12.8. public static void reverse(List<?> list); 反转入参集合list中的元素顺序

12.9. public static void copy(List<? super T> dest, List<? extends T> src); 复制

  • 作用：入参集合src中的元素按顺序将入参集合dest中的元素给顶替掉，
  • 当src.size()<dest.size()时未被替换的元素保持原样
  • 当src.size()>dest.size()时报IndexOutOfBoundsException异常，(复制时当src中保存的元素为对象时会将对象地址传递到dest中且此过程不改变src（即浅复制）)

12.10. public static void swap(List<?> list, int i, int j); 将入参集合list中下标为i的元素与下标为j的元素交换位置

13. commons-lang3工具包

  • 使用需要引入依赖
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

13.1. static Date parseDate(String str, String... parsePatterns); 日期时间字符串转日期时间

  • Date date = DateUtils.parseDate("2024-11-20 02:03:04.555", "yyyy-MM-dd HH:mm:ss.SSS");

13.2. static String format(Date date, String pattern); 日期时间转日期时间转时间日期字符串

  • String dateStr = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");

13.3. static boolean contains(CharSequence seq, CharSequence searchSeq); 判断入参字符串seq中是否入参字符串searchSeq

  • StringUtils.contains("abcdef", "abcdef") == true;
  • StringUtils.contains("abcdef", "cd") == true;
  • StringUtils.contains("abcdef", "") == true;
  • StringUtils.contains("", "") == true;
  • StringUtils.contains("abcdef", "ce") == false;
  • StringUtils.contains("abcdef", "gh") == false;
  • StringUtils.contains("abcdef", null) == false;
  • StringUtils.contains(null, "abc") == false;
  • StringUtils.contains(null, null) == false;

13.4. static boolean equals(CharSequence cs1, CharSequence cs2); 判断字符串是否相等

  • StringUtils.equals("abcdef", "abcdef") == true;
  • StringUtils.equals("", "") == true;
  • StringUtils.equals(null, null) == true;
  • StringUtils.equals("abcdef", "AbcdeF") == false;
  • StringUtils.equals("abcdef", "abc") == false;
  • StringUtils.equals("abcdef", "") == false;
  • StringUtils.equals("abcdef", null) == false;

13.5. static boolean equalsIgnoreCase(CharSequence cs1, CharSequence cs2); 判断字符串是否相等忽略大小写

  • StringUtils.equalsIgnoreCase("abcdef", "abcdef") == true;
  • StringUtils.equalsIgnoreCase("", "") == true;
  • StringUtils.equalsIgnoreCase(null, null) == true;
  • StringUtils.equalsIgnoreCase("abcdef", "AbcdeF") == true;
  • StringUtils.equalsIgnoreCase("abcdef", "abc") == false;
  • StringUtils.equalsIgnoreCase("abcdef", "") == false;
  • StringUtils.equalsIgnoreCase("abcdef", null) == false;

13.6. static String join(Object[] array, String delimiter); 数组中各元素的toString()结果以指定字符串连接(字符串拼接)

  • StringUtils.join(new String[]{"abcd","efgh","ijk"}, "||") == "abcd||efgh||ijk";
  • StringUtils.join(new String[]{"abcd","efgh","ijk"}, "") == "abcdefghijk";
  • StringUtils.join(new String[]{"abcd","efgh","ijk"}, null) == "abcdefghijk";
  • StringUtils.join(new String[]{"abcd","","ijk"}, "||") == "abcd||||ijk";
  • StringUtils.join(new String[]{"abcd",null,"ijk"}, "||") == "abcd||||ijk";
  • StringUtils.join(new File[]{new File("aaa"),new File("bbb")}, "||") == "aaa||bbb";

13.7. static String join(Iterable<?> iterable, String separator); 集合中各元素的toString()结果以指定字符串连接(字符串拼接)

  • Collection<E>继承自Iterable<E>
  • ArrayList<String> list = new ArrayList<>();
    list.add("aaa"); list.add("bbb"); list.add("ccc");
    StringUtils.join(list, "||") == "aaa||bbb||ccc";

13.8. static boolean isBlank(CharSequence cs); 判断是否为空白字符串

  • StringUtils.isBlank("abc") == false;
  • StringUtils.isBlank(" abc") == false;
  • StringUtils.isBlank(" ") == true;
  • StringUtils.isBlank(" ") == true;
  • StringUtils.isBlank("") == true;
  • StringUtils.isBlank(null) == true;

13.9. static boolean isNotBlank(CharSequence cs); 判断是否不为空白字符串

  • StringUtils.isBlank("abc") == true;
  • StringUtils.isBlank(" abc") == true;
  • StringUtils.isBlank(" ") == false;
  • StringUtils.isBlank(" ") == false;
  • StringUtils.isBlank("") == false;
  • StringUtils.isBlank(null) == false;

13.10. static boolean isEmpty(CharSequence cs); 判断是否为空字符串

  • StringUtils.isEmpty("abc") == false;
  • StringUtils.isEmpty(" abc") == false;
  • StringUtils.isEmpty(" ") == false;
  • StringUtils.isEmpty(" ") == false;
  • StringUtils.isEmpty("") == true;
  • StringUtils.isEmpty(null) == true;

13.10. static boolean isNotEmpty(CharSequence cs); 判断是否不为空字符串

  • StringUtils.isNotEmpty("abc") == true;
  • StringUtils.isNotEmpty(" abc") == true;
  • StringUtils.isNotEmpty(" ") == true;
  • StringUtils.isNotEmpty(" ") == true;
  • StringUtils.isNotEmpty("") == false;
  • StringUtils.isNotEmpty(null) == false;

13.11. static T[] toArray(T... items); 根据入参生成数组

  • ArrayUtils.toArray("中国", "美国", "英国", "韩国"); //["中国", "美国", "英国", "韩国"]
  • ArrayUtils.toArray("中国", null, "", "韩国"); //["中国", null, "", "韩国"]
  • ArrayUtils.toArray(); //[]

13.12. static boolean isEmpty(Object[] array); 判断数组是否为空

  • ArrayUtils.isEmpty(ArrayUtils.toArray("中国", "美国", "英国", "韩国")) == false;
  • ArrayUtils.isEmpty(ArrayUtils.toArray()) == true;
  • String[] s = null; ArrayUtils.isEmpty(s) == true;

13.3. static boolean isNotEmpty(T[] array); 判断数据是否不为空

  • ArrayUtils.isNotEmpty(ArrayUtils.toArray("中国", "美国", "英国", "韩国")) == true;
  • ArrayUtils.isNotEmpty(ArrayUtils.toArray()) == false;
  • String[] s = null; ArrayUtils.isNotEmpty(s) == false;

13.4. static T[] subarray(T[] array, int startIndexInclusive, int endIndexExclusive); 获取子数组

  • 子数组和原数组分别占用不同的空间，互相不影响
  • ArrayUtils.subarray(ArrayUtils.toArray("中国", "美国", "英国", "韩国"), 1, 3); //["美国", "英国"]
  • ArrayUtils.subarray(ArrayUtils.toArray("中国", "美国", "英国", "韩国"), 1, 4); //["美国", "英国", "韩国"]
  • ArrayUtils.subarray(ArrayUtils.toArray("中国", "美国", "英国", "韩国"), 1, 5); //["美国", "英国", "韩国"]
  • ArrayUtils.subarray(ArrayUtils.toArray("中国", "美国", "英国", "韩国"), 0, 3); //["中国", "美国", "英国"]
  • ArrayUtils.subarray(ArrayUtils.toArray("中国", "美国", "英国", "韩国"), -1, 3); //["中国", "美国", "英国"]

14. commons-collections工具包

  • 使用需要引入依赖
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-collections4</artifactId>
   <version>4.4</version>
</dependency>

14.1. static boolean isEmpty(Collection<?> coll); 集合判空

  • CollectionUtils.isEmpty(new ArrayList<>()); //true
  • CollectionUtils.isEmpty(new HashSet<>()); //true
  • CollectionUtils.isEmpty(null); //true

14.2. static boolean isNotEmpty(Collection<?> coll); 集合判非空

  • CollectionUtils.isNotEmpty(new ArrayList<>()); //false
  • CollectionUtils.isNotEmpty(new HashSet<>()); //false
  • CollectionUtils.isNotEmpty(null); //false

14.3. static boolean isEmpty(Map map); Maps判空

  • MapUtils.isEmpty(new HashMap<>()); //true
  • MapUtils.isEmpty(null); //true

14.4. static boolean isNotEmpty(Map map); Maps判非空

  • MapUtils.isNotEmpty(new HashMap<>()); //false
  • MapUtils.isNotEmpty(null); //false

14.5. static List<List> partition(List list, int size); List集合切分

  • ListUtils.partition(Arrays.asList(new String[]{"aaa","bbb","ccc","ddd","eee","fff","ggg","hhh"}), 3); //[["aaa", "bbb", "ccc"], ["ddd", "eee", "fff"], ["ggg", "hhh"]]

15. commons-beanutils工具包

  • 使用需要引入依赖
<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.4</version>
</dependency>

15.1. static void copyProperties(Object dest, Object orig); 属性复制（浅复制）

//此方法不建议使用，建议使用spring框架的BeanUtils
/**
 * 假设左侧为targetObject的属性，右侧为sourseObject的属性
 * a <-- a
 * b <-- b
 * c 
 *       d
 */
BeanUtils.copyProperties(targetObject,sourceObject);

16. guava工具包

  • 使用需要引入依赖
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>

16.1. static <E extends @Nullable Object> ArrayList newArrayList(); 创建长度为0的ArrayList集合对象

  • Lists.newArrayList(); //new ArrayList();

16.2. static <E extends @Nullable Object> ArrayList newArrayList(E... elements); 创建ArrayList集合对象并将入参中各元素放入创建的集合对象中

  • Lists.newArrayList("aaa", "", null, "bbb"); //["aaa", "", null, "bbb"]

16.3. static <E extends @Nullable Object> HashSet newHashSet(); 创建长度为0的HashSet集合对象

  • Sets.newHashSet(); //new HashSet();

16.4. static <E extends @Nullable Object> HashSet newHashSet(E... elements); 创建HashSet集合对象并将入参中各元素放入创建的集合对象中

  • Sets.newHashSet("aaa", "", null, "bbb"); //["aaa", "", null, "bbb"]

16.5. static <K extends @Nullable Object, V extends @Nullable Object> HashMap<K, V> newHashMap(); 创建键值对个数为0的HashMap对象

  • Maps.newHashMap(); //new HashMap<>();

16.6. static List<List> partition(List list, int size); List集合切分

  • Lists.partition(Arrays.asList(new String[]{"aaa","bbb","ccc","ddd","eee","fff","ggg","hhh"}), 3); //[["aaa", "bbb", "ccc"], ["ddd", "eee", "fff"], ["ggg", "hhh"]]

17. thumbnailator图片处理工具

  • 使用需要引入依赖
<!-- https://mvnrepository.com/artifact/net.coobird/thumbnailator -->
<dependency>
  <groupId>net.coobird</groupId>
  <artifactId>thumbnailator</artifactId>
  <version>0.4.14</version>
</dependency>

17.1. 使用方式

import net.coobird.thumbnailator.Thumbnails;
import net.coobird.thumbnailator.geometry.Positions;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

@RestController
public class Controller {
    @PostMapping("pictureProcess")
    public void pictureProcess(HttpServletResponse httpServletResponse, @RequestParam("file") MultipartFile multipartFile) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        Thumbnails
                //指定要处理的文件
                .of(multipartFile.getInputStream()) //从流中获取要处理的文件内容
                //.of("C:\\test\\waitHandleImg.jpg") //从指定位置获取要处理的文件内容
                //指定缩放方式
                .scale(0.5) //缩放比例
                //.forceSize(640,360) //缩放尺寸
                //指定输出的图片质量
                .outputQuality(0.6f) //0.0f ~ 1.0f (数值越大质量越高)
                //添加水印
                .watermark(Positions.BOTTOM_RIGHT, //水印位置
                           ImageIO.read(new File("C:\\test\\watermark.png")), //水印内容
                           0.8f) //0.0f ~ 1.0f 水印透明度(数值越小越透明)
                //指定输出图片的格式
                .outputFormat("jpeg") //图片格式
                //输出
                .toOutputStream(byteArrayOutputStream); //输出到流中
                //.toFile("C:\\test\\handledImg.jpg"); //输出到指定位置

        //attachment;（下载） inline;（浏览）
        httpServletResponse.addHeader("Content-Disposition","inline; filename="+new String("处理后的图片.jpeg".getBytes("UTF-8"), "ISO8859-1")); //new String("处理后的图片.jpeg".getBytes("UTF-8"), "ISO8859-1") //URLEncoder.encode("处理后的图片.jpeg","UTF-8")
        ServletOutputStream servletOutputStream = httpServletResponse.getOutputStream();
        servletOutputStream.write(byteArrayOutputStream.toByteArray());

        byteArrayOutputStream.close();
        servletOutputStream.close();
    }
}
posted @ 2022-06-14 22:26  略乏旅人  阅读(442)  评论(0)    收藏  举报