Java基础知识16--Arrays、System常用方法使用(获取linux系统下当前用户路径)

1.Arrays概述

Arrays类位于 java.util 包中，主要包含了操作数组的各种方法。

1.1 toString方法

一维数组转字符串

public static String toString(int[] a)

案例：

int[] array1 = new int[]{1, 2, 3};
int[] array2={6,7,8,9};
System.out.println(Arrays.toString(array1)); //[1, 2, 3]
System.out.println(Arrays.toString(array2)); //[6, 7, 8, 9]

1.2 deepToString方法

如果是一维数组，toString方法可以很好的适用。但遇到多维数组时，需要使用deepToString把数组完全转成字符串。

public static String deepToString(Object[] a)

案例：

int[][] deepArray = new int[][]{{1, 3},{2, 4}};
System.out.println(Arrays.deepToString(deepArray)); //[[1, 3], [2, 4]]

1.3 fill方法

填充数组

将指定的int值分配给指定的int数组的指定范围的每个元素。 要填充的范围从索引fromIndex扩展到索引toIndex

public static void fill(int[] a,int fromIndex,int toIndex,int val)

案例：

int[] array1 = new int[5];
Arrays.fill(array1, 2);
System.out.println(Arrays.toString(array1)); //[2, 2, 2, 2, 2]

int[] array2 = new int[5];
Arrays.fill(array2, 1, 4, 2); //部分填充
System.out.println(Arrays.toString(array2));//[0, 2, 2, 2, 0]

1.4 sort方法

1.4.1 数组元素排序

    public static void main(String[] args) {
        int[] array1 = new int[]{3, 10, 4, 0, 2};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); //[0, 2, 3, 4, 10]

        int[] array2 = new int[]{3, 10, 4, 0, 2};
        Arrays.parallelSort(array2); //和sort相比是这个是并行的
        System.out.println(Arrays.toString(array2)); //[0, 2, 3, 4, 10]

        int[] array3 = new int[]{3, 10, 4, 0, 2};
        Arrays.sort(array3, 0, 4); //部分排序
        System.out.println(Arrays.toString(array3)); //[0, 3, 4, 10, 2]

    }

1.4.2 对其他对象数组进行排序

一个对象数组，排序算法需要重复比较数组中的元素。不同的类比较元素的规则是不同的，但是排序算法只应该调用类提供的比较方法，只要所有的类就比较的时候提供的方法达成一致，那么排序算法就能开始工作。这个在排序时对象之间进行比较方法就可以是一个接口，所有需要比较的对象继承这个接口并且实现比较的方法，就可以对这些对象进行排序。
如果一个类想启用对象排序，那么就应该实现Comparable接口。

    public static void main(String[] args){
        Employee[] employees = new Employee[3];
        employees[0] = new Employee(20);
        employees[1] = new Employee(10);
        employees[2] = new Employee(30);
        Arrays.sort(employees);
        for(Employee e : employees){
            System.out.println(e); //Employee{id=10} Employee{id=20} Employee{id=30}
        }

    }
    static class Employee implements Comparable<Employee>{
        private int id;
        public Employee(int id){this.id = id;}
        @Override
        public int compareTo(Employee o) {
            return this.id - o.id;
        }
        @Override
        public String toString() {
            return "Employee{" + "id=" + id + '}';
        }
    }

1.4.3 自定义排序规则

String[] names = {"tom", "alice", "fred"};
Arrays.sort(names);
System.out.println(Arrays.toString(names));//[alice, fred, tom]

假如想根据字符串的长度而不是根据字典顺序对字符串排序，但是String类我们是无法修改的。上面的代码对String数组进行排序，只能按照字典顺序对String数组进行排序。
Arrays.sort方法和Collections.sort方法都提供了一个可以接收Comparator实例作为第二个参数的版本。
要按照长度比较字符串，定义一个实现Comparator<String>的类。

    public static void main(String[] args){
        String[] names = {"tom", "alice", "fred"};
        Arrays.sort(names, new LengthComparator());
        System.out.println(Arrays.toString(names)); //[tom, fred, alice]
    }

    public static class LengthComparator implements Comparator<String> {
        @Override
        public int compare(String o1, String o2) {
            return o1.length() - o2.length(); // 返回值<0,对应false,则o1与o2的顺序不交换；返回值>0,对应true,则o1与o2的顺序交换
        }
    }

像Comparator、Runable等这=一些接口有一个特点就是只有一个抽象方法（其他的都是static或者default的方法），比如继承Comparator接口只需要重写compare方法，继承Runnable接口只需要重写run方法，这种类型的接口被称为函数式接口，可以被lambda表达式所代替。
比如上面根据字符串的长度进行排序的代码，Arrays.sort的第二个参数是需要实现了Comparator接口的实例，用lambda表达是就可以写成这样：

    public static void main(String[] args){
        String[] names = {"tom", "alice", "fred"};
        Comparator<String> comp = (first, second) -> {return first.length() - second.length();};
        /*Comparator<String> comp = new Comparator<String>() {
            @Override
            public int compare(String first, String second) {
                return first.length() - second.length();
            }
        };*/
        Arrays.sort(names, comp);
        System.out.println(Arrays.toString(names));

    }

1.5 equals与deepEquals

数组的比较

deepEquals用于判定两个指定数组彼此是否深层相等，此方法适用于任意深度的嵌套数组。

equals用于判定两个数组是否相等，如果两个数组以相同顺序包含相同元素，则返回true。

public static boolean equals(int[] a,int[] a2)

public static boolean deepEquals(Object[] a1,Object[] a2)

案例：

int[] array = new int[]{1, 2, 3};
int[] array2 = new int[]{1, 2, 3};
System.out.println(Arrays.equals(array, array2)); //true

int[][] deepArray1 = new int[][]{{1, 3},{2, 4}};
int[][] deepArray2 = new int[][]{{1, 3},{2, 4}};
System.out.println(Arrays.equals(deepArray1, deepArray2)); //false
System.out.println(Arrays.deepEquals(deepArray1, deepArray2)); //true

 1.6 asList方法

将数组转化成List集合

1.6.1 源码分析

Arrays.asList()所作操作：

    @SafeVarargs
    public static <T> List<T> asList(T... var0) {
        return new Arrays.ArrayList(var0);
    }

看上去是个很正常的方法，然而实际上你点进到 ArrayList 发现，其实 ArrayList 并不是我们平时用的 ArrayList，而是 Arrays 里面的一个内部类。

 而且这个内部类没有 add，clear，remove方法(即没有重写实现这些方法)，所以抛出的异常其实来自于AbstractList。

public void add(int index, E element) {
       throw new UnsupportedOperationException();
}

public E remove(int index) {
      throw new UnsupportedOperationException();
}

Arrays.asList()不是坑 设计的初衷就是要生成一个不可更改的list,保证数据的安全性的场景，比如要生成一个常量list，里面的值都是约定好了的，不能被代码随意修改，这种就很需要这个方法，就算jdk不提供，需要用到的也是会自己生成一个内部类去实现这个的。

总结：

• Arrays.asList() 不要乱用，底层其实还是数组。ArrayList底层是Object[]数组。
• 如果使用了 Arrays.asList() 的话，最好不要使用其集合的操作方法。
• List list = new ArrayList<>(Arrays.asList("a", "b", "c")) 可以在外面这样包一层真正的 ArrayList。

注意：

（1）该方法适用于对象型数据的数组（String、Integer...）

（2）该方法不建议使用于基本数据类型的数组（byte,short,int,long,float,double,boolean）

（3）该方法将数组与List列表链接起来：当更新其一个时，另一个自动更新

（4）不支持add()、remove()、clear()等方法

1.6.2 使用案例

(1)对象类型(String型)的数组数组使用asList()

        String[] strings = {"aa", "bb", "cc"};
        List<String> stringList = Arrays.asList(strings);
        for(String str : stringList){
            System.out.print(str + " "); //控制台输出：aa bb cc
        }    

(2)对象类型(Integer)的数组使用asList()

        Integer[] ints = new Integer[] {1, 2, 3};
        List<Integer> intList = Arrays.asList(ints);
        for(int i : intList){
            System.out.print(i + " "); //控制台输出：1 2 3 
        }

debug模式查看：

(3)基本数据类型的数组使用asList()

    public static void main(String[] args){
        int[] ints = new int[]{1, 2, 3};
        List<int[]> intList = Arrays.asList(ints);
        System.out.print("3、基本数据类型的数组使用asList()，出错(输出的是一个引用，把ints当成一个元素了)：");
        for(Object o : intList){
            System.out.print(o.toString());//基本数据类型的数组使用asList()，出错(输出的是一个引用，把ints当成一个元素了):[I@37bba400
        }
        
    }

注意：基本数据类型int的数组调用asList之后得到的List只有一个元素，这个元素就是元素类型的数组。而封装类Integer数组调用asList是把数组中每个元素加到了List中。

(4)当更新数组或者List,另一个将自动获得更新

    public static void main(String[] args){
        Integer[] ints = new Integer[]{1, 2, 3};
        List<Integer> intList = Arrays.asList(ints);

        for (Integer integer : intList) {
            System.out.print(integer+" ");  //控制台输出：1 2 3
        }
        ints[0]=100;
        System.out.println();
        for (Integer integer : intList) {
            System.out.print(integer+" ");  //控制台输出：100 2 3 
        }
    }

(5)获取真正的 ArrayList

    public static void main(String[] args){
        Integer[] ints = new Integer[]{1, 2, 3};
        List<Integer> intList = new ArrayList<>(Arrays.asList(ints));
        ints[0]=100;
        for (Integer integer : intList) {
            System.out.print(integer+" ");
        }
        System.out.println();
        System.out.println(Arrays.toString(ints));
    }

通过debug模式查看可知：

1.7 copyOf和copyOfRange

1.7.1 copyOf方法

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

public static int[] copyOf(int[] original,int newLength)

案例：

int []arr = {10,20,30,40,50};
int []arr1 = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(arr1)); //[10, 20, 30]
System.out.println(Arrays.toString(arr));  //[10, 20, 30, 40, 50]

注意：copyOf底层调用的是System.arraycopy()方法实现复制。

System中提供了一个native静态方法arraycopy(),可以使用这个方法来实现数组之间的复制。对于一维数组来说，这种复制属性值传递，修改副本不会影响原来的值。对于二维或者一维数组中存放的是对象时，复制结果是一维的引用变量传递给副本的一维数组，修改副本时，会影响原来的数组。

native 方法不是用Java语言写的，一般都是出于性能考虑，或者用c++,来操作Java不能直接操作的系统资源，因此，System.arraycopy()具有更好的性能。

c语言有memcpy(void *destin, void *source, unsigned n)方法，函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，性能很优秀。

1.8 stream方法

以指定的数组作为源，返回顺序Stream。

public static <T> Stream<T> stream(T[] array)

注意：T - 数组元素的类型；

案例：

    public static void main(String[] args) {
        String[] address={"tiantai","shaoxing","hangzhou"};
        List<Integer> lengthList = Arrays.stream(address).map(String::length).collect(Collectors.toList());
        System.out.println(lengthList);
    }

控制台输出：

[7, 8, 8]

 2.System类

System 类包含一些有用的类字段和方法。它不能被实例化。

public final class System
extends Object

• public final class System 被final修饰，表示无法被继承
• private System() 方法私有化，表示无法创建实例
• 所有方法全部是static修饰的

2.1 getProperty方法

获取指定键指示的系统属性。

public static String getProperty(String key)

其中key主要有以下参数：

• user.dir：当前工程或者模块的工作目录
• user.home当前用户主目录，Windows的形式：C:\Users\Rongdi
• user.name 当前用户名
• line.separator 行分符，也就是我们文件结尾的换行符
• file.separator  路径分隔符，各个系统都不一样，win \
• java.version 系统版本
  

默认情况下， java 设置了哪些系统变量：

java.version Java 运行时环境版本 
java.vendor Java 运行时环境供应商 
java.vendor.url Java 供应商的 URL 
java.home Java 安装目录 
java.vm.specification.version Java 虚拟机规范版本 
java.vm.specification.vendor Java 虚拟机规范供应商 
java.vm.specification.name Java 虚拟机规范名称 
java.vm.version Java 虚拟机实现版本 
java.vm.vendor Java 虚拟机实现供应商 
java.vm.name Java 虚拟机实现名称 
java.specification.version Java 运行时环境规范版本 
java.specification.vendor Java 运行时环境规范供应商 
java.specification.name Java 运行时环境规范名称 
java.class.version Java 类格式版本号 
java.class.path Java 类路径 
java.library.path 加载库时搜索的路径列表 
java.io.tmpdir 默认的临时文件路径 
java.compiler 要使用的 JIT 编译器的名称 
java.ext.dirs 一个或多个扩展目录的路径 
os.name 操作系统的名称 
os.arch 操作系统的架构 
os.version 操作系统的版本 
file.separator 文件分隔符(在 UNIX 系统中是"/") 
path.separator 路径分隔符(在 UNIX 系统中是":") 
line.separator 行分隔符(在 UNIX 系统中是"/n") 
user.name 用户的账户名称 
user.home 用户的主目录 
user.dir 用户的当前工作目录

案例1(windows系统)：

    public static void main(String[] args) {
        System.out.println(System.getProperty("user.dir")); //当前工程或者模块的工作目录
        System.out.println(System.getProperty("user.home")); //当前用户主目录
        System.out.println(System.getProperty("user.name")); //当前用户名
        System.out.println(System.getProperty("file.separator")); //路径分隔符，各个系统都不一样，win \
        System.out.println(System.getProperty("java.version")); //系统版本
    }

控制台输出：

D:\workFiles\flep-test\flep-boot
C:\Users\14032
lucky
\
1.8.0_151

案例2(linux系统的flep用户)：

    public static void main(String[] args) {
        System.out.println(System.getProperty("user.dir")); //当前工程或者模块的工作目录
        System.out.println(System.getProperty("user.home")); //当前用户主目录
    }

控制台输出：

/home/flep/onlineTest
/home/flep

2.2 getProperties方法

确定当前的系统属性。

public static Properties getProperties()

案例：

System.out.println(System.getProperties());

控制台输出：

{java.runtime.name=Java(TM) SE Runtime Environment, sun.boot.library.path=D:\software\jdk\jdk1.8.0_151\jre\bin, java.vm.version=25.151-b12, java.vm.vendor=Oracle Corporation, java.vendor.url=http://java.oracle.com/, path.separator=;, java.vm.name=Java HotSpot(TM) 64-Bit Server VM, file.encoding.pkg=sun.io, user.country=CN, user.script=, sun.java.launcher=SUN_STANDARD, sun.os.patch.level=, java.vm.specification.name=Java Virtual Machine Specification, user.dir=D:\workFiles\flep-test\flep-boot, java.runtime.version=1.8.0_151-b12, java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment, java.endorsed.dirs=D:\software\jdk\jdk1.8.0_151\jre\lib\endorsed, os.arch=amd64, java.io.tmpdir=C:\Users\14032\AppData\Local\Temp\, line.separator=

2.3 currentTimeMillis 方法

返回当前时间（以毫秒为单位）。 产生一个当前的毫秒，这个毫秒其实就是自1970年1月1日0时起的毫秒数

public static long currentTimeMillis()

案例：

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        Random random=new Random();
        try {
            Thread.sleep(random.nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime-startTime+"ms");
    }

控制台输出：

7724ms

2.4 arraycopy方法

将指定源数组中的数组从指定位置复制到目标数组的指定位置。

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

用来实现将源数组部分元素复制到目标数组的指定位置。各个参数功能如下：

Object src：源数组；

Int srcPos：源数组中的起始位置；

Object dest：目标数组；

int destPos：目标数据中的起始位置；

int length，指定复制的长度；

    public static void main(String[] args) {
        int[] arr1 = { 0, 1, 2, 3, 4 };
        int[] arr2 = { 9, 9, 9, 9, 9 };

        System.arraycopy(arr1, 2, arr2, 0, 3);

        arr1[3] = 8;

        for (int i = 0; i < 5; i++){
            System.out.print(arr2[i] + " ");
            //2 3 4 9 9
        }
    }

 

参考文献：https://blog.csdn.net/zhzh402/article/details/79670509

https://blog.csdn.net/Mrs_chens/article/details/103726297

System.arraycopy 参考文献：https://blog.csdn.net/qq_32440951/article/details/78357325