资料搜集-JAVA系统的梳理知识5-JAVA基础篇&JVM

 

- [Collections 工具类和 Arrays 工具类常见方法](#collections-工具类和-arrays-工具类常见方法)
    - [Collections](#collections)
        - [排序操作](#排序操作)
        - [查找,替换操作](#查找替换操作)
        - [同步控制](#同步控制)
    - [Arrays类的常见操作](#arrays类的常见操作)
        - [排序 : `sort()`](#排序--sort)
        - [查找 : `binarySearch()`](#查找--binarysearch)
        - [比较: `equals()`](#比较-equals)
        - [填充 : `fill()`](#填充--fill)
        - [转列表 `asList()`](#转列表-aslist)
        - [转字符串 `toString()`](#转字符串-tostring)
        - [复制 `copyOf()`](#复制-copyof)


# Collections 工具类和 Arrays 工具类常见方法

## Collections

Collections 工具类常用方法:

1. 排序
2. 查找,替换操作
3. 同步控制(不推荐，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合)

###  排序操作

```java
void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。
```

**示例代码:**

```java
     ArrayList arrayList = new ArrayList();
      arrayList.add(-1);
      arrayList.add(3);
      arrayList.add(3);
      arrayList.add(-5);
      arrayList.add(7);
      arrayList.add(4);
      arrayList.add(-9);
      arrayList.add(-7);
      System.out.println("原始数组:");
      System.out.println(arrayList);
      // void reverse(List list)：反转
      Collections.reverse(arrayList);
      System.out.println("Collections.reverse(arrayList):");
      System.out.println(arrayList);


      Collections.rotate(arrayList, 4);
      System.out.println("Collections.rotate(arrayList, 4):");
      System.out.println(arrayList);

      // void sort(List list),按自然排序的升序排序
      Collections.sort(arrayList);
      System.out.println("Collections.sort(arrayList):");
      System.out.println(arrayList);

      // void shuffle(List list),随机排序
      Collections.shuffle(arrayList);
      System.out.println("Collections.shuffle(arrayList):");
      System.out.println(arrayList);

      // void swap(List list, int i , int j),交换两个索引位置的元素
      Collections.swap(arrayList, 2, 5);
      System.out.println("Collections.swap(arrayList, 2, 5):");
      System.out.println(arrayList);

      // 定制排序的用法
      Collections.sort(arrayList, new Comparator() {

         @Override
         public int compare(Integer o1, Integer o2) {
            return o2.compareTo(o1);
         }
      });
      System.out.println("定制排序后：");
      System.out.println(arrayList);
```

### 查找,替换操作

```java
int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素
```

**示例代码：**

```java
      ArrayList arrayList = new ArrayList();
      arrayList.add(-1);
      arrayList.add(3);
      arrayList.add(3);
      arrayList.add(-5);
      arrayList.add(7);
      arrayList.add(4);
      arrayList.add(-9);
      arrayList.add(-7);
      ArrayList arrayList2 = new ArrayList();
      arrayList2.add(-3);
      arrayList2.add(-5);
      arrayList2.add(7);
      System.out.println("原始数组:");
      System.out.println(arrayList);

      System.out.println("Collections.max(arrayList):");
      System.out.println(Collections.max(arrayList));

      System.out.println("Collections.min(arrayList):");
      System.out.println(Collections.min(arrayList));

      System.out.println("Collections.replaceAll(arrayList, 3, -3):");
      Collections.replaceAll(arrayList, 3, -3);
      System.out.println(arrayList);

      System.out.println("Collections.frequency(arrayList, -3):");
      System.out.println(Collections.frequency(arrayList, -3));

      System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");
      System.out.println(Collections.indexOfSubList(arrayList, arrayList2));

      System.out.println("Collections.binarySearch(arrayList, 7):");
      // 对List进行二分查找，返回索引，List必须是有序的
      Collections.sort(arrayList);
      System.out.println(Collections.binarySearch(arrayList, 7));
```

### 同步控制

Collections提供了多个`synchronizedXxx()`方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。

我们知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。Collections提供了多个静态方法可以把他们包装成线程同步的集合。

**最好不要用下面这些方法，效率非常低，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合。**

方法如下：

```java
synchronizedCollection(Collection  c) //返回指定 collection 支持的同步（线程安全的）collection。
synchronizedList(List list)//返回指定列表支持的同步（线程安全的）List。
synchronizedMap(Map m) //返回由指定映射支持的同步（线程安全的）Map。
synchronizedSet(Set s) //返回指定 set 支持的同步（线程安全的）set。
```

### Collections还可以设置不可变集合，提供了如下三类方法：

```java
emptyXxx(): 返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set，还可以是Map。
singletonXxx(): 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。
unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。
上面三类方法的参数是原有的集合对象，返回值是该集合的”只读“版本。
```

**示例代码：**

```java
        ArrayList arrayList = new ArrayList();
        arrayList.add(-1);
        arrayList.add(3);
        arrayList.add(3);
        arrayList.add(-5);
        arrayList.add(7);
        arrayList.add(4);
        arrayList.add(-9);
        arrayList.add(-7);
        HashSet integers1 = new HashSet<>();
        integers1.add(1);
        integers1.add(3);
        integers1.add(2);
        Map scores = new HashMap();
        scores.put("语文" , 80);
        scores.put("Java" , 82);

        //Collections.emptyXXX();创建一个空的、不可改变的XXX对象
        List