好久没看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 方法能对排序好的数组进行二分查找法操作。
下面重点说明下排序：
- 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 循环
语法：
[](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
```
好了，晚安~~