Java SE核心技术——4数组

一、数组的定义

在计算机内存中开辟的连续的存储空间用于存放程序运行中多个相同类型的数据

java中 "类型[ ]" 即数组，并且索引下标从0开始。

数组的声明：

1.数据类型 [] 数组名=new 数据类型[数据的个数] int [] a;数组下标越界编译不会出错运行错误。

int[]money=new int[100] 数组长度：arr.length

2数据类型 数组名称 [] int a [];

二、数组的创建及初始化

（1）静态初始化：在定义数组的同时定义元素的值

简化格式：
数据类型 [] 数组名称 = {值1，值2，…};
完整格式：
数据类型 [] 数组名称 = new 数据类型 [] {值1，值2，…};

public class Test
{
    public static void main(String[] args)
    {
        int[] arr1={1,2,3,4,5};//简化格式
        int[] arr2 = new int []{1,2,3,4,5};//完整格式
    }
}

(2)动态初始化

public class Test
{
    public static void main(String[] args)
    {
        // 动态初始化
        int[] arr = new int [5];
        arr[0] = 0;
        arr[1] = 1;
        arr[2] = 3;
        arr[3] = 4;
        arr[4] = 5;

        // 利用循环实处每一个元素的值
        for(int i = 0;i < arr.length;i++)//数组名.length就是数组长度
        {
            System.out.print(arr[i]+" ");  
        }
    }
}

匿名数组

利用完整格式，可以方便使用匿名数组。
匿名数组就是没有名称的数组，本质是一块没有栈内存指向的堆内存。只能使用一次，用完就被回收了。

public class Test
{
    public static void main(String[] args)
    {
        int[] arr = init();
        for(int i=0; i < arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
     public static int[] init()
     {
         return new int[]{1,2,3,4,5};//方法返回一个匿名数组
     }
}

遍历数组

一维数组类似火车车间

给一个数组：

 int Arr[][]={{5,7,15},{8,4,11},{3,6,13}};

1.for循环遍历

通常遍历数组都是使用for循环来实现。遍历一维数组很简单，遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度。

public class for遍历二维数组 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int Arr[][]={{5,7,15},{8,4,11},{3,6,13}};
		for (int i = 0; i < Arr.length; i++) {
			for (int j = 0; j < Arr[i].length; j++) {
				System.out.print(Arr[i][j]+" ");
			}
		}
	}
}

运行结果
5 7 15 8 4 11 3 6 13

2.foreach遍历

这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时，无须获得数组和集合长度，无须根据索（下标）引来访问数组元素，foreach循环自动遍历数组和集合的每一个元素。

语法格式

for(type element: array)
{
    System.out.println(element);
}

foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组。foreach 语句用于循环访问集合以获取所需信息，但不应用于更改集合内容以避免产生不可预知的副作用。
因此不要对foreach的循环变量赋值。

public class foreach遍历二维数组 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int Arr[][]= {{5,7,15},{8,4,11},{3,6,13}};
		System.out.println("数组中的元素是 ");
		int i=0;
		for(int x[]: Arr) {//行
			i++;
			int j=0;
			for(int e:x) {//列
				j++;
				if(i==Arr.length&&j==x.length) {
					System.out.print(e);//输出最后一个元素，后面不加逗号
				}else
运行结果：
数组中的元素是
5、7、15、8、4、11、3、6、13

3.Arrays工具类中toString静态方法遍历

利用Arrays工具类中的toString静态方法可以将一维数组转化为字符串形式并输出。
已知打印一维数组的API为System.out.println ( Arrays.toString ();，其参数为数组名或数组指针，其支持的数据类型有很多，如：int[]、char[]、byte[]等。

import java.util.Arrays;

public class toString遍历二维数组 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int Arr[][]={{5,7,15},{8,4,11},{3,6,13}};
	    System.out.println("Arr:"+Arrays.toString(Arr));
	    int b[][]={{5,7,15},{8,4,11},{3,6,13}};
	    System.out.println("Arr:"+Arrays.deepToString(b));
	}
}
运行结果：
Arr:[[I@15db9742, [I@6d06d69c, [I@7852e922]
Arr:[[5, 7, 15], [8, 4,11], [3, 6, 13]]

注： Arr:[[I@15db9742, [I@6d06d69c, [I@7852e922] 这种输出结果是因为：Arr是一个二维数组。相当于一个长度为3的数组，但是这个数组的元素还是是数组。 当执行Arrays.toString的时候相当于遍历数组，并且输出数组的元素，但是这个数组的元素是数组，所以这里输出的是数组元素的地址。

.Arrays.deepToString()与Arrays.toString()的区别

• Arrays.deepToString()主要用于数组中还有数组的情况，而Arrays.toString()则相反，对于Arrays.toString()而言，当数组中有数组时，不会打印出数组中的内容，只会以地址的形式打印出来。

  public class test {
  
    public static void main(String[] args) {
  
        int a[] = {1, 2, 3};
        System.out.println(Arrays.toString(a));
        int b[][] = {{1, 2, 3}, {4, 5, 6}};
        System.out.println(Arrays.toString(b));
        System.out.println(Arrays.deepToString(b));
    }
  }
  - 结果
  [1, 2, 3]
  [[I@14ae5a5, [I@7f31245a]
  [[1, 2, 3], [4, 5, 6]]
  

一、冒泡排序（两个for循环）

外层for循环：控制遍历数组（数组最后一个元素不需要遍历。数组长度arr-1，最后一个元素无法和后一个比较）

for（int i=0；i<（数组长度-1）;i++){

内层for循环：控制元素交换即冒泡，一般为数组长度-外层循环变量-1

//交换规则：两两交换，小的在左大的在右

for（int j=0;j<arr.length-i-1;j++){}

//j<arr.length-i-1已经排好序的减掉

}

冒泡排序要知道

内外循环两层套

外环数组遍历到

内环边界计算好

左右元素判大小

临时变量交换要

for(int i=0;i<arr.length-1;i++){
//外层for循环
   for(int j;j<arr.length-i-1;j++){
 //内层for循环
   if(arr[j]>arr[j+1]){
          int temp=arr[j+1];
          array [j+1]=array[j];
           array [j+1]=temp;

        }
   }
}

一、二维数组(*了解)多排多列

概念：数组里的每一个元素都是是一个一维数组的数组被称为二维数组。i
定义： 静态初始化：

 int[][] arr1 = {{1,2,3},{1,2}};//简化格式
 
 int[][] arr2 = new int[][] {{1,2,3},{4,5}};//完整格式

动态初始化：

  int arr[][] = new int[2][3];//2 行个数，3，列个数

不规则二维数组的使用：

public class Test
{
    public static void main(String[] args)
    {
        int[][] arr=new int[3][]
        {
            {1,2,3,4},
            {1,2},
            {3,4}
        };
        for(int i=0;i<arr.length;i++)  //利用两重for循环打印输出二维数组的元素。
        {
            for(int j=0;j<arr[i].length;j++)
            {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }    
}