day4_java数组

-----------------------------------------------------------

                                     数组                                        

数组也是容器，用来存储数据

同一数组的数据类型应当相同

1.数组声明

Int [] arr;

Int[]  表示int型的数组，结合起来是一个引用类型

//也可以写成Int arr []；但不是很好理解

2.动态初始化

Arr = newint[3];

Int [] arr = newint[3]//也可以和声明写在一行

（1）我们指定数组的大小（长度），系统分配空间赋值

（2）系统分配的默认值

数据类型	默认值
整数	0
浮点	0.0
布尔	false
String	null
所有的引用类型	null
字符	‘\u0000‘

 3.静态初始化

（1）我们指定值，系统分配存储空间大小

（2）Int [] arr1 = {11,22,33};   //只能放在一行

        Int [] arr2 =new int[] {33,44};   //可以分成两行来写

       =        Int [] arr2;

                 Arr2 = new int[]{33,44};  

4.赋值

    Arr[0] =11;

    Arr[1] =22;

    Arr[2] =33;

5.循环输出

普通for循环：

        for(int i = 0 ; i < arr.length ; i++) {

           System.out.println(arr[i]);

        }

 

增强for循环：

        //增强for循环遍历输出:针对集合和数组

        for(int n:arr) {

           System.out.println(n);

        }

（1）    只能顺序遍历

（2）    不能指定范围遍历，只能遍历所有

（3）    不能改变数组元素的值

---------------------------------------------------------

                                               栈                                                 

用来模拟后进先出的一种数据结构

（1）存基本数据类型和引用类型的名字

（2）空间相对小

（3）频繁创建和销毁

---------------------------------------------------------

                                           堆                                              

（1）    用来存对象

（2）    空间稍大

（3）    不会频繁创建和销毁

内存图：

二维数组：

1.    动态初始化

Int arr = new int [3][3];

2.    静态初始化

       Int arr = {{1,2,3},{1,2,3},{1,2,3}};

或者：int arr = new int [][]{{1,2,3},{1,2,3},{1,2,3}};

3.多维数组理解

java中其实没有真正意义上的多维数组，比如二维数组可以看作一维数组元素中存的是一个一维数组；三维数组可以看成一维数组里面存储了一个二维数组。

不规则数组

  1.动态初始化

int [][] arr = new int [3][];

//高维数组的元素也是一个数组（a[0],a[1],a[2]也是一个数组）

int [0] = new int[1];

int [1] = new int[1];

int [2] = new int[1];

  2.静态初始化

int [][] arr = {{1},{1,2},{1,2,3}}

不规则数组练习：杨辉三角形

package day5;

import java.util.Scanner;

public class Demo12 {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入行数：");
		int n = scanner.nextInt();
		int[][] arr = new int[n][];
		
		for (int i = 0; i < arr.length; i++) {
			arr[i] = new int[i + 1];
		}
		for (int i = 0; i < arr.length; i++) {
			arr[i][0] = 1;
			arr[i][i] = 1;
		}
		for (int i = 1; i < arr.length; i++) {
			for (int j = 1; j < arr[i].length - 1; j++) {
				arr[i][j] = arr[i -1][j -1] + arr[i -1][j];
			}
		}
		
		System.out.println("杨辉三角前" + n + "行：");
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
	}

}

-----------------------------------------------------------

                                         几个基本算法                                  

求最大值

int max ;

        max = arr[0];

        for(int i=0 ; i<arr.length;i++) {

           if(max < arr[i]) {

               max = arr[i];

           }

        }

求最小值

int min ;

        min = arr[0];

        for(int i=0 ; i<arr.length;i++) {

           if(min > arr[i]) {

               min = arr[i];

           }

        }

        System.out.println("最小值是："+min)

排序：

    （1）冒泡排序：

相邻的数字比较，并将最小的元素交换到前面

int temp;

        int arr [] = {11,222,3,45,67};

        for(int i =0;i<arr.length-1;i++) {//轮数

           for(int j=0;j<arr.length-1-i;j++) {//次数

               if(arr[j]>arr[j+1]) {//相邻两个数比较

                   temp = arr[j];

                   arr[j] = arr[j+1];

                   arr[j+1]=temp;

               }

           }

        }

        for(int n:arr) {

           System.out.println(n);

        }

（2）选择排序

某个位置和这个位置后 的所有元素比较

int temp;

        int [] arr = {11,222,45,21,456};

        for(int i=0 ; i<arr.length-1;i++) {//位置

           for( int j = i+1 ; j<arr.length; j++) {//位置后的所有元素

               if(arr[i] > arr[j]) {

                   temp = arr[i];

                   arr[i]=arr[j];

                   arr[j]=temp;

               }

           }         

        }

        for(int n :arr) {
           System.out.println(n);
        }

插入排序：

检查数组列表的每个元素，并将其放入已排序元素的适当位置

public static void main(String[] args)

        {

                 int[]arr = {10,20,56,26,55,36};

                 int temp = 0;

                 for(int i = 1; i < arr.length ; i++){//位置

                         for(int j = 0 ; j < i ; j++ ){ //前面所有的元素

                                  //比较

                                  if( arr [j] > arr [i])

                                 {

                                          temp= arr [i];//保存

                                  //覆盖

                                  for(int k = i ; k > j ; k-- )

                                  {
                                          arr[k]= arr[k-1];

                                  }
                                  arr[j]= temp;

                                  }

        }
}

        for(intn : arr) {

                 System.out.println(n);
        }

}

删除元素：后面元素往前覆盖

插入元素：前面元素往后覆盖

 

首尾交换方法：

int [] arr = {1,2,3,4,5};

        for(int n:arr) {

           System.out.println(n);

        }

        int temp;

        temp=arr[0] ;

        arr[0] =arr[arr.length-1];

        arr[arr.length-1]=temp;

        for(int n:arr) {

           System.out.println(n);

       

        }

二分查找方法:

 class Ex4
{
    public static void main(String[] args)
    {
        int [] arr = new int[]{2,6,3,1,5,7,5};
        int start = 0;
        int end = arr.length - 1;
        // 要查找的数
        int num = 2;
        int middle = (start + end) / 2;
        while(num != arr[middle]) {
            if (num > arr [middle])
            {
                start = middle +1;
            }else{
                end = middle - 1;
        }
        
    }
    }

 

数组复制的多种方法：

 import java.util.Arrays;

class Ex5
{
    public static void main(String[] args)
    {    
        int [] arr1 = new int []{1,56,2,45,3};
//        int [] arr2;
        //方法一
//        arr2 = arr1;
        //方法二
    //    arr2 = arr1.clone();
        //方法三
        int [] arr2 = new int[arr1.length];
        for (int i = 0 , j = 0; i < arr1.length ; i++ ,j++)
        {
            arr2 [j] =  arr1 [i];
        }
        //方法四
        System.arraycopy(arr1,0,arr2,0,arr1.length);

        //方法五
        arr2 = Arrays.copyOf(arr1,5);

        //arraycopy和copyof的区别:copyof不需要创建数组


        for(int n : arr2)
            {
            System.out.println(n);
        }
    }
}

 

Arrays工具类使用，常用方法

import java.util.Arrays;//需要提前导入包

int [] arr = {24,1,667,33,5};
        String s = Arrays.toString(arr);
        System.out.println(s);
        //把数组转换成字符串
        System.out.println(Arrays.toString(arr));
        //排序，升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        // [起始位置，终止位置)，也就是到终止位置减一
        Arrays.sort(arr,1,4);
        System.out.println(Arrays.toString(arr));
        //优势在多处理器情况下
        Arrays.parallelSort(arr);
        System.out.println(Arrays.toString(arr));
        //二分查找，前提：要排序;返回下标
        //元素不存在的情况则返回负的插入点减一
        System.out.println(Arrays.binarySearch(arr,667));

        //指定查找范围（数组，起始位置，终止位置，元素），不包括终止位置，在【0,4）之间查找
        System.out.println(Arrays.binarySearch(arr,1,4,24));
        //判断两个数组是否相同：相同 true  长度和对应元素都相同
        int []arr2 = {24,1,2,677,5};
        int [] arr3 = {24,1,2,677,5};
        System.out.println(Arrays.equals(arr2,arr3));

        //填充，用指定元素填充数组
        System.out.println(Arrays.toString(arr));
        Arrays.fill(arr,111);
        //[起始位置，终止位置)
        

        //复制数组
        int [] arr4 ={24,1,667,33,5};
        System.out.println(Arrays.toString(arr4));
        int [] arr5;
        //数组，个数
        arr5 = Arrays.copyOf(arr4,2);
        System.out.println(arr4);
        System.out.println(arr5);

        //范围复制
        arr5 = Arrays.copyOfRange(arr4,1,4);
        System.out.println(Arrays.toString(arr5));

 

 

 

二维数组：

  1.动态初始化

int [][] arr = new int [3][3];

  2.静态初始化

int [][] arr = {{1,2,3},{1,2,3},{1,2,3}};

 

多维数组理解

数组中没有真正意义上的多维数组，二维数组可以理解为一维数组里面成员存的是一维数组；三维数组可以理解为一维数组里面成员存的是二维数组；

 

不规则数组

  1.动态初始化(三行两列)

       int [][] arr = new int[3][2];
        int [][] arr1 = new int[3][];
        arr1[0] = new int[2];
        arr1[1] = new int[3];
        arr1[2] = new int[4];

  2.静态初始化(三行两列)

       int [][] arr2 = {{12,2},{5,8,6},{14,12,44,3}};
        int [][] arr2 = new int[][]{{12,2},{5,8,6},{14,12,44,3}};

杨辉三角形

import java.util.Scanner;

public class Ex7 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入行数：");
        int n = scanner.nextInt();
        int[][] arr = new int[n][];
        
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i + 1];
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i][0] = 1;
            arr[i][i] = 1;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = 1; j < arr[i].length - 1; j++) {
                arr[i][j] = arr[i -1][j -1] + arr[i -1][j];
            }
        }
        
        System.out.println("杨辉三角前" + n + "行：");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

    }

}