JSE6-数组枚举，集合，泛型
1.数组
1.1 概述
数组是由相同类型的若⼲项数据组成的⼀个数据集合，数组是引⽤类型。
数组的声明 char charArray [] 或 char[] charArray;
Java中，即使数组是由原始类型构成，数组也是⼀个对象。声明不能创建对象本⾝，⽽创建的是⼀个引⽤，该引⽤可被⽤来引⽤数组。数组元素使⽤的实际内存可由 new 语句或数组初始化软件动态分配。
- 数组的创建
java定义一维数组并赋值int[] x={1,2,3,4};
int[] y= new int[]{1,2,3,4,5}; //注：此种[]中没有具体个数
char []  charArray= new char [20];  //每个值都被初始化0(\u0000-null)字符，如果对象数组则初始化为null.
数组创建后在内存⾥⾯占⽤连续的内存地址。
数组的静态性：数组⼀旦被创建，就不能更改数组的长度。
数组变量要初始化后才能使⽤：所有变量的初始化(包括数组元素)是保证系统安全的基础，变量绝不能在未初始化状态使⽤。
1.2 数组代码
数组的下标都从 0 开始。length是数组元素的数量。所有元素的访问就通过数组的下标来访问，如上例的 list[i]，随着 i 的值发⽣变化，就依次访问 list[0]、list[1]、list[2]…
for 循环语句
int a[] = new int[3];
//旧的写法，赋值
for(int i=0;i<a.length;i++){
a[i] = i;
}
//新的写法，取值
for(int i : a){
System.out.println(i);
}
1.3 多维数组
多维数组定义和初始化
twoDim[1] = new int [4];
twoDim[2] = new int [6];
twoDim[3] = new int [8];
或
int [][] twoDim = new int [3][4];
但是这样的是⾮法的
int [][] twoDim = new int [][4];//⾮法
//多维数组赋值-1
class FillArray{
public static void main (String args[]){
int[ ][ ] matrix = new int[4][5]; //⼆维数组的声明和创建
for (int row=0; row < 4; row++) {
for (int col=0; col < 5; col++){
matrix[row][col] = row + col; //⼆维数组的访问，为元素赋值
}
}
}
}
//多维数组赋值-2
double[][] c ={
{1.0, 2.0, 3.0, 4.0},
{0.0, 1.0, 0.0, 0.0},
{0.0, 0.0, 1.0, 0.0}
};
N维数组
N维数组就是⼀维的 N-1 维数组，⽐如：三维数组就是⼀维的⼆维数组。三维以⾄多维数组都是⼀个思路，⼀维数组–>维数组–>三维数组的实例:
//三维数组赋值
class Fill3DArray{
public static void main (String args[]){
int[ ][ ][ ] M = new int[4][5][3];
for (int row=0; row < 4; row++){
for (int col=0; col < 5; col++){
for (int ver=0; ver < 3; ver++){
M[row][col][ver] = row + col + ver;
}
}
}
}
}
1.4 数组的复制
数组创建后，⼤⼩不可调整。但可以⽤引⽤变量来引⽤⼀个全新的数组：
⽰例:
Integer [] arrayI = new Integer[6];
arrayI[0] = 3;
System.out.println("arrayI.length-1>"+ arrayI.length+","+arrayI[0]);
arrayI = new Integer[10];
System.out.println("arrayI.length-2>"+ arrayI.length+","+arrayI[0]);
运⾏结果:
arrayI.length-1>6,3
arrayI.length-2>10,null
arraycopy()。 拷贝数组.
public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length)
//原始数组
int srcArray[] = { a,b, c, d, e, f };
//新的数组，⽐原始数组⼤
int desArray[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
//把原始数组的值拷贝到新的数组
System.arraycopy(srcArray, 0, desArray, 0, srcArray.length);
拷贝完成后，数组 desArray 有如下内容：a,b,c,d,e,f,4,3,2,1。srcArray的值不变.
1.5：数组的排序
1.5.1 冒泡排序
基本思路：对未排序的各元素从头到尾依次⽐较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第⼀轮⽐较排序后便可把最⼤（或最⼩）的元素排好，然后再⽤同样的⽅法把剩下的元素逐个进⾏⽐较，就得到了你所要的顺序。
可以看出如果有 N 个元素，那么⼀共要进⾏ N-1 轮⽐较，第 I 轮要进⾏ N-I 次⽐较。（如：有5 个元素，则要进⾏ 5-1 轮⽐较。第 3 轮则要进⾏ 5-3 次⽐较）
⽰例如下：
public static void bubbling() {
int a[] = {3,4,1,5,2};
//冒泡排序
for (int i = 0; i < a.length; i++) {
/
/注意j的开始值是i+1，因为按照排序规则，⽐a[i]之前的已经排序了.
for (int j = i + 1; j < a.length; j++) {
//此例为升序，如果降序则改为a[i] < a[j]
if (a[i] > a[j]) {
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
//检测⼀下排序的结果
for (int i : a) {
System.out.println("i=" + i);
}
}
运⾏结果：
i=1
i=2
i=3
i=4
i=5
1.5.2：选择排序
基本思路：⽐较之后将最⼩的放在最数组前⾯.
从所有元素中选择⼀个最⼩元素 a[i]放在 a[0]（即让最⼩元素 a[i]与 a[0] 交换），作为第⼀轮；
第⼆轮是从 a[1]开始到最后的各个元素中选择⼀个最⼩元素，放在 a[1] 中；……依次类推。n 个数要进⾏（n－1）轮。 ⽐较的次数与冒泡法⼀样多，但是在每⼀轮中只进⾏⼀次交换，⽐冒泡法的交换次数少，相对于冒泡法效率⾼。
⽰例如下：
public static void selection(){
int a[] = new int[]{3,4,1,5,2};
//选择法排序
int temp;
for (int i = 0; i<a.length; i++) {
int lowIndex = i;
//出最⼩的⼀个的索引
for (int j=i+1;j<a.length;j++) {
//默认升序，如果降序则改为a[j] > a[lowIndex]
if (a[j] < a[lowIndex]) {
lowIndex = j;
}
}
//交换
temp=a[i];
a[i]=a[lowIndex];
a[lowIndex]=temp;
}
//检测⼀下排序的结果
for(int i : a){
System.out.println("i="+i);
}
}
1.5.3：插⼊法排序
基本思路：每拿到⼀个元素，都要将这个元素与所有它之前的元素遍历⽐较⼀遍，让符合排序顺序的元素挨个移动到当前范围内它最应该出
现的位置。
⽐如: 就⽤前⾯的数组，我们要对⼀个有5个元素的数组进⾏升序排列，假设第⼀个元素的值被假定为已排好序了，
那么我们就将第2个元素与数组中的部分进⾏⽐较，如果第2个元素的值较⼩，则将它插⼊到第1个元素的前⾯，现在就有两个元素排好序
了，
我们再将没有排序的元素与排好序的元素列表进⾏⽐较，同样，如果⼩于第⼀个元素，就将它插⼊到第⼀个元素前⾯，但是，如果⼤于第⼀
个元素的话，我们就将它再与第2个元素的值进⾏⽐较，⼩于的话就排在第2个元素前⾯，⼤于的话，就排在第 2 个元素的后⾯。
以此类推，直到最后⼀个元素排好序。
⽰例如下：
//3.插⼊法排序
public static void insertSort() {
int a[] = new int[5];
a[0] = 3;
a[1] = 4;
a[2] = 1;
a[3] = 5;
a[4] = 2;
int temp;
for (int i = 1; i < a.length; i++) {// i=1开始，因为第⼀个元素认为是已经排好序了的
//交换，当前这个和之前的数组元素对⽐，如果⼩于前⾯元素则交换.[(j > 0) && (a[j] < a[j - 1])这个写法值得学习]
//默认升序，如果降序则a[j] < a[j - 1]修改为 a[j] < a[j - 1]
for (int j = i; (j > 0) && (a[j] < a[j - 1]); j--) {
temp = a[j];
a[j] = a[j - 1];
a[j - 1] = temp;
}
}
//检测⼀下排序的结果
for (int i : a) {
System.out.println("i=" + i);
}
}
1.5.4：希尔(Shell)法排序
从前⾯介绍的冒泡排序法，选择排序法，插⼊排序法可以发现，如果数据已经⼤致排好序的时候，其交换数据位置的动作将会减少。
例如在插⼊排序法过程中，如果某⼀整数d[i]不是较⼩时，则其往前⽐较和交换的次数会更少。如何⽤简单的⽅式让某些数据有⼀定的⼤⼩次序呢？Donald
基本思路：先将数据按照固定的间隔分组，例如每隔 4 个分成⼀组，然后排序各分组的数据，形成以分组来看数据已经排序，
从全部数据来看，较⼩值已经在前⾯，较⼤值已经在后⾯。
将初步处理了的分组再⽤插⼊排序来排序，那么数据交换和移动的次数会减少。可以得到⽐插⼊排序法更⾼的效率。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。