Arrays

java.util.Arrays 提供了大量的静态方法用来实现数组常见的操作

  • public static String toString(数组) 将参数数组变成字符串（按照默认格[元素1, 元素2, …]）

  • public static void sort(数组) 按照默认（升序）对数组进行排序

    ArrayList

    • ArrayList可以任意改变长度
    • ArrayList 中E为指定泛型，泛型只能是引用类型，不能是基本类型
    • 如果希望存储基本类型数据，则必须使用基本类型所对应的“包装类”
    • byte —-> Byte
    • short —-> Short
    • int —-> Integer
    • long —-> Long
    • float —-> Float
    • double —-> Double
    • char —-> Character
    • boolean —-> Boolean
    • ArrayList直接打印得到的不是地址值，而是其中的内容
    常用方法

  • public boolean add(E e)

  • public void add(int i, E e)
  • public E get(int index)
  • public boolean isEmpty()
  • public E remove(int index)
  • public int size()

  • public E set(int i, E e)

    Calendar

  • java.util.Calendar 是一个抽象类，直接已知子类为 GregorianCalendar

  • static Calendar getInstance() 返回一个日历类
  • public int get(int field) 返回给定字段的值
  • public void set(int field, int value) 给指定字段设置值
  • public abstract void add(int field, int amount) 给指定字段增加/减少指定值

  • public Date getTime() 把日历对象转换成为日期对象

    Collection

    Collection 是所有单列集合的根接口 ，主要有两个子接口

  • List

    • 有序的集合（存取元素顺序相同）
    • 允许存储重复的元素
    • 有索引，可以使用普通的for循环遍历
  • Set
    • 不允许存储重复元素
    • 没有索引，不可使用for循环遍历

Collection常用功能

  • public boolean add(E e)
  • public void clear()
  • public boolean remove(E e)
  • public boolean contains(E e)
  • public boolean isEmpty()
  • public int size()

  • public Object[] toArray()

    Collections

    常用方法

  • public static <T> boolean addAll(Collection<T> c, T...elements) 往集合中添加一些元素

  • public static void shuffle(List<?> list) 打乱集合顺序
  • public static <T> void sort(List<T> list) 将集合中元素按照默认规则排序
  • public static <T> void sort(List<T> list, Comparator<? super T>) 将集合中元素按照指定规则排序

使用 sort(List<T> list) 的前提

  • 被排序的集合里面存储的元素必须实现 Comparable ，并且重写接口中的 compareTo() 方法
  • 排序规则： return this - obj 为升序， return obj - this 为降序

自定义规则的前提

  • 必须生成一个 Comparator 对象，重写其中的 compare(o1, o2) 方法
  • return o1 - o2 为升序, return o2 - o1 为降序 ```java package Pro;

import java.util.ArrayList; import java.util.Collections; import java.util.Comparator;

public class DemoCollections { public static void main(String[] args) { ArrayList list = new ArrayList<>(); Person p1 = new Person(“Alice”, 18); Person p2 = new Person(“Bob”, 15); Person p3 = new Person(“Cathelin”, 30); Person p4 = new Person(“Donald”, 18); Collections.addAll(list, p1, p2, p3, p4); System.out.println(list); // 按照年龄升序排序 Collections.sort(list); System.out.println(list); //自定义排序方式 Collections.sort(list, new Comparator() { @Override public int compare(Person o1, Person o2) { int result = o1.getAge() - o2.getAge(); //按照年龄升序 if(result == 0){ result = o1.getName().charAt(0) - o2.getName().charAt(0); } return result; } }); System.out.println(list); } }

  2. <a name="SkMi3"></a>
  3. # Date
  5. - `java.util.Date` 表示特定的瞬间，精确到毫秒
  6. - `Date()` 获取当前日期
  7. - `Date(long dateNum)` 将毫秒值转化为日期
  8. - `System.currentTimeMillis()` 与 `Date.getTime()` 获取日期的毫秒值
  9. <a name="G5rUe"></a>
  10. # DateFormat
  12. - `java.text.DateFormat`  是一个抽象类，直接已知子类为 `SimpleDateFormat` 
  13. - `String format(Date date)` 按照指定模式将Date格式化为符合模式的字符串
  14. - `Date parse(String source)` 把符合模式的字符串解析为Date日期
  15. - `SimpleDateFormat(String pattern)` 使用给定的模式构造
  16. <a name="A7uYf"></a>
  17. # HashMap
  19. - `HashMap<K,V>` 集合 `implements` `Map<K,V>` 接口
  21. **HashMap集合的特点** 
  23. - 底层是哈希表，查询速度特别快
  24.    - JDK1.8之前：数组+单向链表
  25.    - JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8），提高查询速度
  27. **存储自定义类型键值** 
  29. - 必须重写 `hashCode()` 方法
  30. - 必须重写 `equals()` 方法
  31. <a name="zH6cD"></a>
  32. # HashSet
  34. - **哈希值** ：是一个十进制的整数，由系统随机给出，模拟了对象的内存地址，使用 `Object.hashCode()` 可以获取对象的哈希值
  35. - `String` 类重写了 `hashCode` 方法，不同字符串可能返回相同的哈希值
  37. **集合中不能存储重复元素的原理** 
  39. - 在调用 `add` 方法时，会调用新增元素s2的 `hashCode` 方法计算哈希值，若s2的哈希值与已有元素s1哈希值相同（哈希冲突），则会调用 `s1.equals(s2)` ，若返回true，则认为s1与s2相同，不进行存储。
  40. - 底层实现原理：哈希表（数组+链表/红黑树）
  42. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/1674030/1611823929215-b312df52-4d91-49b2-9867-3211bc69bd69.png#height=206&id=IVnPI&margin=%5Bobject%20Object%5D&name=image.png&originHeight=412&originWidth=848&originalType=binary&ratio=1&size=115382&status=done&style=none&width=424)<br />**存储自定义类型元素** 
  44. - 必须重写 `hashCode` 方法
  45. - 必须重写 `equals` 方法
  46. ```java
  47. package API;
  49. import java.util.HashSet;
  50. import java.util.Objects;
  52. public class DemoHashCode {
  53.     public class Person{
  54.         private String name;
  55.         private int age;
  57. //        @Override
  58. //        public int hashCode() {
  59. //            return name.hashCode() + age;
  60. //        }
  61. //
  62. //        @Override
  64.         @Override
  65.         public boolean equals(Object o) {
  66.             if (this == o) return true;
  67.             if (o == null || getClass() != o.getClass()) return false;
  68.             Person person = (Person) o;
  69.             return age == person.age && name.equals(person.name);
  70.         }
  72.         @Override
  73.         public int hashCode() {
  74.             return Objects.hash(name, age);
  75.         }
  76. //        public boolean equals(Object obj) {
  77. //            Person person = (Person) obj;
  78. //            return this.name.equals(person.name) && this.age == person.age;
  79. //        }
  81.         public Person(String name, int age) {
  82.             this.name = name;
  83.             this.age = age;
  84.         }
  86.         public String getName() {
  87.             return name;
  88.         }
  90.         public void setName(String name) {
  91.             this.name = name;
  92.         }
  94.         public int getAge() {
  95.             return age;
  96.         }
  98.         public void setAge(int age) {
  99.             this.age = age;
  100.         }
  102.         @Override
  103.         public String toString() {
  104.             return "Person{姓名:" + name + ",年龄：" + age + "}";
  105.         }
  106.     }
  107.     public static void main(String[] args) {
  108.         DemoHashCode hs = new DemoHashCode();
  109.         DemoHashCode.Person p1 = hs.new Person("大聪明", 18);
  110.         DemoHashCode.Person p2 = hs.new Person("大聪明", 18);
  111.         DemoHashCode.Person p3 = hs.new Person("大聪明", 19);
  112.         HashSet<Person> set = new HashSet<>();
  113.         set.add(p1);
  114.         set.add(p2);
  115.         set.add(p3);
  116.         for (Person person : set) {
  117.             System.out.println(person);
  118.         }
  119.     }
  120. }

Hashtable

  • 任何 非null 对象都可以用作键或值
  • 单线程，因此线程安全，但是速度慢

  • Hashtable已被取代，但其子类 Properties 仍然活跃

    Iterator

    迭代器用于对集合进行遍历

  • boolean hasNext() 判断集合中是否有下一个元素

  • E next() 返回迭代的下一个对象

必须使用Iterator的实现类才能使用以上两个方法，一般使用 Iterator<E> iterator() 返回此Collection元素上进行迭代的迭代器

  1. package API;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Iterator;
  7. public class DemoIterator {
  8.     public static void main(String[] args) {
  9.         Collection<String> coll = new ArrayList<>();
  10.         coll.add("富强");
  11.         coll.add("民主");
  12.         coll.add("文明");
  13.         coll.add("和谐");
  14.         Iterator<String> iterator = coll.iterator();
  15.         while(iterator.hasNext()){
  16.             System.out.println(iterator.next());
  17.         }
  18.     }
  19. }

LinkedHashMap

具有可预测迭代顺序的 HashMap

LinkedHashSet

具有可预测迭代顺序的 HashSet

LinkedList

  • 使用 LinkedList 特有的方法时，不能使用多态（编译看左边，会报错）
  • LinkedList 可以看作是一个“栈”结构

特有方法

  • public void addFirst(E e) 等效于 public void push(E e)
  • public void addLast(E e) 等效于 public void add(E e)
  • public E getFirst()
  • public E getLast()
  • public E removeFirst() 等效于 public E pop()
  • public E removeLast()

    List

    java.util.List 接口是有序的 Collection

特有方法

  • public void add(int index, E e)
  • public E get(int index)
  • public E remove(int index)

  • public E set(int index, E e)

    Map

    Map的常用子类

  • HashMap<K,V>

  • LinkedHashMap<K,V>

Map的常用方法

  • public V put(K key, V value) 把指定的键与指定的值添加到Map集合中
    • 如果key不重复，返回值V是null
    • 如果key重复，会使用新的value替换map中的value，返回被替换的value值
  • public V remove(Object key) 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值
  • public Set<K> keySet() 获取Map集合中所有的键，存储到Set集合中
  • public Set<Map.Entry<K,V>> entrySet() 获取到Map集合中所有的键值对对象的集合

Map.Entry (Map集合中的内部接口Map.Entry)

  • 当Map集合一创建，就会在Map集合中创建一个Entry对象，用来记录键与值的映射关系
  • public K getKey() 返回key的值
  • public V getValue() 返回value的值

Math

  • public static double abs(double num) 获取绝对值
  • public static double ceil(double num) 向上取整
  • public static double floor(double num) 向下取整
  • public static long round(double num) 四舍五入

  • Math.PI 圆周率近似值

    Object

  • java.lang.Object 类是Java语言中的根类，即所有类的父类，它描述的所有方法子类都可以使用。

  • 常用的方法

    • String toString() 返回该对象的字符串表示（打印对象时其实就是调用的 toString 方法）
    • public boolean equals(Object obj) 判断其他某个对象是否与此对象相等

      Objects

  • equals 方法：对两个对象进行比较，可以防止空指针异常

    1. public static boolean equals(Object a, Object b){
    2.   return (a == b) || (a != null && a.equals(b));
    3. }

  • 判断对象是否为空

    1. public static <T> T requireNonNull(T obj){
    2.   if (obj == null)
    3.       throw new NullPointerException();
    4.   return obj;
    5. }

    Random

  • 用于生成随机数字 Random r = new Random(); ```java package oop.basic;

import java.util.Random;

/Random类用来生成随机数字/ public class DemoRandom { public static void main(String[] args) { Random r = new Random(); int num1 = r.nextInt(); System.out.println(“随机数1为：” + num1); // 产生整型范围内的整数值 int num2 = r.nextInt(100); // 产生一个[0,100)的随机数 System.out.println(“随机数2为：” + num2); for (int i = 0; i < 10; i++) { int num = r.nextInt(20); System.out.println(num); } } }

  2. <a name="mGnpv"></a>
  3. # Scanner
  5. - 用于从键盘中获取输入值 `Scanner sc = new Scanner(System.in);`
  6. - `sc.nextInt()` 获取一个整数
  7. - `sc.next()` 获取一个字符串（不带空格）
  9. <a name="zTy2g"></a>
  10. # String
  11. **1.字符串的特点**
  13. - 字符串的内容永不改变
  14. - 由于字符串内容不可改变，所以字符串可以共享使用
  16. **2.字符串的创建**
  18. - `public String()` ：创建一个空白字符串
  19. - `public String(char[] array)` ：根据字符数组来创建对应的字符串
  20. - `public String(byte[] array)` ：根据字节数组来创建对应的字符串
  21. - 直接创建
  22. ```java
  23. package oop.basic;
  25. public class DemoString {
  26.     public static void main(String[] args) {
  27.         //使用空参构造
  28.         String str1 = new String();
  29.         //根据字符数组
  30.         char[] charArray = new char[]{'a', 'b', 'c', 'd'};
  31.         String str2 = new String(charArray);
  32.         //根据字节数组
  33.         byte[] byteArray = new byte[]{97, 98, 99, 100, 101};
  34.         String str3 = new String(byteArray);
  35.         //直接创建
  36.         String str4 = "Hello, world";
  37.         System.out.println(str1);
  38.         System.out.println(str2);
  39.         System.out.println(str3);
  40.         System.out.println(str4);
  41.     }
  42. }

3.字符串的常量池: 只有程序中直接双引号生成的字符串，才在字符串常量池（堆内存）中，所有指向这一 字符串常量 的引用具有相同的地址
4.常用字符串方法

  • 比较方法
    • public boolean equals(Object obj)
    • public boolean equalsIgnoreCase(Object obj) 忽略大小写进行内容比较
  • 获取方法
    • public int length() 返回字符串长度
    • public String concat(String str) 拼接字符串
    • public char charAt(int index) 返回字符
    • public int indexOf(String str) 查找参数字符串在本字符串中首次出现的索引位置，若找不到，返回-1
  • 截取方法
    • public String substring(int index) 返回从 index 至字符串末尾的字符串
    • public String substring(int begin, int end) 返回[begin, end)范围内的字符串
  • 转换方法
    • public char[] toCharArray() 将当前字符串拆分成为字符数组
    • public byte[] getBytes() 获得当前字符串的字节数据
    • public String replace(CharSequence oldString, CharSequence newString) 替换字符串 ```java package oop.basic;

import java.nio.charset.StandardCharsets;

public class DemoStringConvert { public static void main(String[] args) { String str1 = “Hello”; String str2 = new String(new char[]{‘w’, ‘o’, ‘r’, ‘l’, ‘d’}); String str3 = str1.concat(“, “).concat(str2); String str4 = str3.replace(“l”,”o”); char[] charArray = str3.toCharArray(); byte[] byteArray = str3.getBytes(StandardCharsets.UTF_8); System.out.println(str3); System.out.println(str4); System.out.println(charArray); for (int i = 0; i < byteArray.length; i++) { System.out.print(byteArray[i] + “ “); } } }

```

  • 分割方法

    • public String[] split(String regex) 按照 regex （其实是一个正则表达式）将字符串切分为若干部分，返回一个列表

      StringBuilder

  • 由于字符串不可改变，所以进行字符串的相加，内存中会有多个中间字符串，占用空间多，效率低下

  • 而 StringBuilder 的长度可变，因此可以提高字符串操作的效率
  • StringBuilder 初始化 byte[] value = new byte[16]
  • 构造方法
    • StringBuilder() 构造方法， 构造一个不带任何字符，容量为16的缓冲区
    • StringBuilder(String str) 构造一个字符串生成器，初始化为指定字符串的内容
    • StringBuilder(CharSequence seq)
    • StringBuilder(int capacity)
  • StringBuilder append(Object obj) 向sb对象中添加obj对象的字符串表示形式 ，具有多种重载方式， append 方法实际返回的是 this ，因此无需 接受返回值

  • public String toString()将sb对象转化成为String对象

    System

  • public static long currentTimeMillis() 返回毫秒表示的当前时间

  • public static void arraycopy(Object src, int srcPos, Object dest, int desPos, int length) 将数组中指定区间拷贝到另一个数组中