Arrays的使用

package myAllTest.TArrays;

import java.util.Arrays;
import java.util.List;

public class UseArrays {

 /**
  * Arrays最让我们经常使用，所以这里我决定把他常用的功能集中出来举个例子，方便使用
  *
  * 这里我们还是先来看一下文档的解释：
  * 此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
  * 除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

  * @param args
  */
 
 public static void main(String[] args) {
  UseArrays ua=new UseArrays();
  ua.Ts_Alist();//测试aslist
  ua.Ts_BinarySearch();//测试binarySearch
  ua.Ts_CopyOf();//测试copyOf
  ua.Ts_CopyOfRange();//测试CopyOfRange
  ua.Ts_DeepEquals();//测试DeepEquals
  ua.Ts_Fill();//测试Fill
  ua.Ts_Sort();//测试Sort
 }
 
 /**
  * 我还是按照文档方法的顺序来示例吧
  */
 
 
 /*
  * 1、aslist
  * 这个方法，他接受的时一个字符串数组（可见我们换成其它类型的时候出现了报错）
  * 功能：将我们的字符串数组转变成list形式
  */
 public void Ts_Alist()
 {
  List<String> list=Arrays.asList("aa","bb","cc");
  System.out.println(list.toString());
  /**
   * 结果:[aa, bb, cc]
   */
 }
 
 
 /**
  * 2、binarySearch这个重载的方法有点多,但基本都是大同小异
  * 功能：使用二分法方式索引到我们想要的
  * 在这里我选择其中一个重载方法进行举例
  */
 
 public void Ts_BinarySearch()
 {
  String[] str=new String[]{"1","2","3"};
  int index=Arrays.binarySearch(str, "2");
  System.out.println(index);
  /**
   * 结果:1
   */
 }
 
 
 /*
  * 3、copyOf同上只举一个例子
  * 功能：复制截取指定的数组到一个新数组
  */
 
 public void Ts_CopyOf()
 {
  String[] str=new String[]{"1","2","3"};
  //当我们复制正常大小的时候便是很正常的复制
  String[] str1=Arrays.copyOf(str, 3);
  //当我们所要复制的大小超出了要复制数组的大小时，便会自动扩容，因此我们可以使用这点特性来做一些比较方便的事
  String[] str2=Arrays.copyOf(str, 4);
  System.out.println(str1[2]);
  System.out.println(str2[3]);//未越界错误，说明扩容了
  
  /**
   * 结果: 3
   *     null
   */
 }
 
 
 /*
  * 4、copyOfRange同上只举一个例子
  * 功能：复制截取指定范围的数组到一个新数组
  */
 
 public void Ts_CopyOfRange()
 {
  String[] str=new String[]{"1","2","3"};
  String[] str1=Arrays.copyOfRange(str, 1,3);//此处不包含3(1<=x<3)
  System.out.println(str1[0]);
  
  /**
   * 结果: 2
   */
 }
 
 /*5、deepEquals的使用
  * 说明：如果两个数组引用均为 null，或者它们引用了包含相同元素数量的数组，并且两个数组中的所有相应元素对都是深层相等的，
  * 则认为这两个数组引用是深层相等的。
  如果满足以下任意条件之一，则两个 null 元素 e1 和 e2 可能是深层相等的：
  e1 和 e2 都是对象引用类型的数组，并且 Arrays.deepEquals(e1, e2) 将返回 true。
  e1 和 e2 都是相同基本类型的数组，并且 Arrays.equals(e1, e2) 的适当重载将返回 true。
  e1 == e2
  e1.equals(e2) 将返回 true。
  注意，此定义支持任意深度的 null 元素。
  *
  */
 
 public void Ts_DeepEquals()
 {
  String[] str=new String[]{"1","2","3"};
  String[] str1=new String[]{"4","5","6"};
  String[] str2=new String[]{"1","2","3"};
  
  Integer[] integer=new Integer[]{1,2,3};
  
  boolean result= Arrays.deepEquals(str, str1);
  boolean result2=Arrays.deepEquals(str, str2);
  boolean result3=Arrays.deepEquals(str, integer);
  
  
  System.out.println(result);
  System.out.println(result2);
  System.out.println(result3);
  
  /**
   * 结果: false true false
   */
  
  //由于deepHashCode  和deepToString比较简单，我就不单独举例方法，直接在下方处理了
   String st=Arrays.deepToString(str1);
   System.out.println(st);
   
   int st2=Arrays.deepHashCode(str);
   System.out.println(st2);
   /**
    * 结果: [4, 5, 6]
     78481
    */
 }
 
 /*
  * equals在这里我就省略了，毕竟经常用相信大家也不陌生
  * 好，接下来是fill
  * 功能：填充（顾名思义）由于他的重载方法也很多，大家更多的可以去阅读文档，我这里仍然只使用其中一个重载方法举出一个例子
  */
 
 public void Ts_Fill()
 {
  String[] str=new String[5];
  Arrays.fill(str, "china");
  System.out.println(Arrays.asList(str).toString());
  /**
   * 结果: [china, china, china, china, china]
   */
 }
 
 /*
  *写了那么多了总算是到了最后几个了，hashCode，我这里也不说了，不过说明我还是贴上
  *        hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值
  * toString 这个方法呢  ToString方法会返回一个“以文本方式表示”此对象的字符串。前面我也用到过，大家可以往上面再去看一遍
  *或者查阅文档
  *
  * 当然sort，也还是要举例一下的
  *功能：排序
  * 说明：该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function",
  * Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。
  * 此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
  * 可见这是一个快速排序法的变异版本，但有大量的数据采用它效果是非常明显的，超出你的想象
  */
 public void Ts_Sort()
 {
  Integer[] str=new Integer[]{3,1,5,2,6};
   Arrays.sort(str);
   
   for(int i:str)
   {
    System.out.println(i);
   }
  
  /**
   * 结果: 1
    2
    3
    5
    6
   */
 }
 
}