Java 入门之数组基础和用法

好久没看java基础了，很多时候能写出来，但是真跟别人讲讲，可能不是那么容易，所以，还是重新看看以前学过的知识吧。下面我要说的是 数组。

翻看几年前的画，2017来了.jpg

1. 什么是Java数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
在Java中，用来存储固定大小的同类型元素的集合。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。

2. 声明数组变量

语法：

double[] myList; // 首选的方法
  double myList[]; // 效果相同，但不是首选方法 ```
#####3. 创建数组
```arrayRefVar = new dataType[arraySize];```

上面的语法语句做了两件事：
- 使用 dataType[arraySize] 创建了一个数组。
- 把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：
```dataType[] arrayRefVar = new dataType[arraySize];```

另外，你还可以使用如下的方式创建数组。
```dataType[] arrayRefVar = {value0, value1, ..., valuek};```

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。
  
    public class Demo2 {
    public static void main(String[] args) {
        double[] mylist = { 1.9, 2.9, 3.4, 3.5 };

        // 打印所有数组元素
        for (int i = 0; i < mylist.length; i++) {
            System.out.println("打印所有数组元素:  " + mylist[i] + " ");
        }

        // 计算所有元素的总和
        double total = 0;
        for (int i = 0; i < mylist.length; i++) {
            total += mylist[i];
            System.out.println("计算所有元素的总和 :" + total);

        }
        //查找最大元素
        double max = mylist[0];
          for (int i = 1; i < mylist.length; i++) {
             if (mylist[i] > max){
                 max = mylist[i];
             } 
          }
          System.out.println("最大元素 is " + max);
    }   }

运行结果为：

打印所有数组元素: 1.9
打印所有数组元素: 2.9
打印所有数组元素: 3.4
打印所有数组元素: 3.5
计算所有元素的总和 : 1.9
计算所有元素的总和 : 4.8
计算所有元素的总和 : 8.2
计算所有元素的总和 : 11.7
最大元素 is 3.5

###### 4.  Arrays 类
Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类包含各种静态方法用于排序和搜索数组、数组的比较和填充数组元素。这些方法为所有基本类型所重载。
它具有以下功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法,按升序。
- 比较数组：通过 equals 方法比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。




![java.util.Arrays 类.png](http:https://img.haomeiwen.com/i2293787/8ea42c659da27cc1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

下面重点说明下排序：
- 1.对基本数据类型的数组的排序

public class Demo3 {

/**
 * @param 数组的用法
 */
public static void main(String[] args) {
    // 定义一个整数数组
    int[] scores = { 70, 93, 84, 63 };

    Arrays.sort(scores); // 排序

    for (int i = 0; i < scores.length; i++) {
        System.out.println(scores[i] + "  ");

    }

    int[] nums = new int[] { 25, 7, 9, 89, 53 };
    //将数组转换为字符串
    System.out.println("输出数组nums中的元素：" + Arrays.toString(nums));
}

}

运行结果如下：

63
70
84
93
输出数组nums中的元素：[25, 7, 9, 89, 53]

- 2.对复合数据类型的数据的排序**
 　　函数原型：
```  (1)public static<T> void sort(T[] a，Comparator c)  根据指定比较器产生的顺序对指定对象数组进行排序。
(2)public static<T> void sort(T[] a，int fromIndex，int toIndex，Comparator c)  根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。```　
　　说明：这个两个排序算法是“经过调优的**合并排序**”算法。

import java.util.Arrays;
import java.util.Comparator;

public class Demo4 {

Point[] arr; //声明数组

Demo4() {
    arr = new Point[4]; // 定义对象数组arr，并分配存储的空间
    for (int i = 0; i < 4; i++)
        arr[i] = new Point();
}

public static void main(String[] args) {

    Demo4 sort = new Demo4();
    sort.arr[0].x = 2;
    sort.arr[0].y = 1; // 初始化，对象数组中的数据
    sort.arr[1].x = 2;
    sort.arr[1].y = 2;
    sort.arr[2].x = 1;
    sort.arr[2].y = 2;
    sort.arr[3].x = 0;
    sort.arr[3].y = 1;

    Arrays.sort(sort.arr, new MyComprator()); // 使用指定的排序器，进行排序
    for (int i = 0; i < 4; i++)
        // 输出排序结果
        System.out.println("(" + sort.arr[i].x + "," + sort.arr[i].y + ")");
    }
}

class Point {
    int x;
    int y;
}

// 比较器，x坐标从小到大排序；x相同时，按照y从小到大排序
class MyComprator implements Comparator {
    public int compare(Object arg0, Object arg1) {
        Point t1 = (Point) arg0;
        Point t2 = (Point) arg1;
        if (t1.x != t2.x)
            return t1.x > t2.x ? 1 : -1;
        else
            return t1.y > t2.y ? 1 : -1;
    }

}

运行结果如下：

(0,1)
(1,2)
(2,1)
(2,2)

###### 5.  foreach 循环

语法：
[![语法.png](http:https://img.haomeiwen.com/i2293787/507740e6d028b4cc.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)](http://img.mukewang.com/53940fb30001445a02820079.jpg)

public class Demo5 {

public static void main(String[] args) {

    String [] myList = {"丽丽", "哈哈", "胡话", "粒粒" };

    System.out.println("*****使用for循环输出数组中的元素*****");
    for (int i = 0; i < myList.length; i++) {
        System.out.println(myList[i]);
    }
    
    System.out.println();
    System.out.println("*****使用foreach循环输出数组中的元素*****");
    for (String string : myList) {
        System.out.println(string );
    }
}

}

运行结果：

*****使用for循环输出数组中的元素*****
丽丽
哈哈
胡话
粒粒

*****使用foreach循环输出数组中的元素*****
丽丽
哈哈
胡话
粒粒

##### 6. 数组作为函数的参数
数组可以作为参数传递给方法。例如，
下面的例子就是一个打印 int 数组中元素的方法:

public class Demo6 {
// 数组作为函数的参数
public static void main(String[] args) {

    printArray(new int[] { 3, 1, 2, 6, 4, 2 });
}

public static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
}

}

运行结果：

3 1 2 6 4 2

##### 7. 数组作为函数的返回值
一个方法也可以返回一个数组。例如，下面所示的方法返回一个数组，它是另一个数组的反转：

// 数组作为函数的返回值
public static int[] reverse(int[] list) {
    int[] result = new int[list.length];

    for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
        result[j] = list[i];
    }
    return result; // result 数组作为函数的返回值

}

##### 8. 多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

String str [ ] [ ] = new String[3][4];
int [ ] [ ] num=new int [2][3];

解析：
```二维数组 a 可以看成一个两行三列的数组。```

public class Demo7 {

@SuppressWarnings("unused")
public static void main(String[] args) {

    String str [ ] [ ] = new String[3][4];
    int[][] nums = new int[2][3];
    // 定义一个两行三列的二维数组并赋值
    int[][] num = { { 1, 2, 3 }, { 4, 5, 6 } };

    // 定位行
    for (int i = 0; i < num.length; i++) {
        // 定位行的元素
        for (int j = 0; j < num[i].length; j++) {
            // 依次输出每个元素
            System.out.println(num[i][j]);
        }
        System.out.println();
    }
}

}

关于多维数组的后续，后面会讲到。

** PS：*  数组的去重、增加、删除数组元素
   

import java.util.ArrayList;
import java.util.List;

public class Demo8 {

public static void main(String[] args) {
    testA();
    System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&");
    testB();
    System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&");
    testC();
}

// 去掉数组中重复的值
public static void testA() {
    String[] str = { "AA", "bb", "CC", "DD", "AA", "CC", "HH" };
    for (String elementA : str) {
        System.out.print(elementA + " ");
    }
    List<String> list = new ArrayList<String>();
    for (int i = 0; i < str.length; i++) {
        if (!list.contains(str[i])) {
            list.add(str[i]);
        }
    }

    System.out.println();
    String[] newStr = list.toArray(new String[1]); // 返回一个包含所有对象的指定类型的数组
    for (String elementB : newStr) {
        System.out.print(elementB + " ");
    }
    System.out.println();
}

// 删除数组中其中一个元素
public static void testB() {
    String[] str = { "AA", "bb", "CC", "DD","FF" };
    for (String elementA : str) {
        System.out.print(elementA + " ");
    }
    // 删除CC
    List<String> list = new ArrayList<String>();
    for (int i = 0; i < str.length; i++) {
        list.add(str[i]);
    }
    list.remove(2); // list.remove("CC")
    System.out.println();
    String[] newStr = list.toArray(new String[1]); // 返回一个包含所有对象的指定类型的数组
    for (String elementB : newStr) {
        System.out.print(elementB + " ");
    }
    System.out.println();
}

// 在数组中增加一个元素
public static void testC() {
    String[] str = { "AA", "bb", "CC", "DD","FF"};
    for (String elementA : str) {
        System.out.print(elementA + " ");
    }
    // 增加GG
    List<String> list = new ArrayList<String>();
    for (int i = 0; i < str.length; i++) {
        list.add(str[i]);
    }
    list.add(2, "GG"); // list.add("GG")
    System.out.println();
    String[] newStr = list.toArray(new String[1]); // 返回一个包含所有对象的指定类型的数组
    for (String elementB : newStr) {
        System.out.print(elementB + " ");
    }
    System.out.println();
}

}

运行结果如下：
```
AA bb CC DD AA CC HH 
AA bb CC DD HH 
&&&&&&&&&&&&&&&&&&&&&&&&&
AA bb CC DD FF 
AA bb DD FF 
&&&&&&&&&&&&&&&&&&&&&&&&&
AA bb CC DD FF 
AA bb GG CC DD FF 
```
好了，晚安~~