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_);_

        }

_

增强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_= new int[i + 1];_

                }

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

                        arr[0] = 1;__

                        arr= 1;____

                }

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

                        for (int j = 1; j < arr_.length - 1; j++) {_

                                arr_[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_.length; j++) {_

                                System.out.print(arr_[j] + " ");_

                        }

                        System.out.println();

                }

        }

}

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

                                         几个基本算法                                 

求最大值

int max ;

        max = arr[0];

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

           if(max < arr_) {_

               max = arr_;_

           }

        }

求最小值

int min ;

        min = arr[0];

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

           if(min > arr_) {_

               min = arr_;_

           }

        }

        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_> arr[j]) {_

                   temp = arr_;_

                   arr_=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_)_

                                 {

                                          temp= arr_;//保存_

                                  //覆盖

                                  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_;_

        }

        //方法四

        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_= new int[i + 1];
        }
        for (int i = 0; i < arr.length; i++) {
            arr_[0] = 1;
            arr__= 1;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = 1; j < arr_.length - 1; j++) {
                arr_[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_.length; j++) {
                System.out.print(arr_[j] + " ");
            }
            System.out.println();
        }

    }

}

__

__

评论

暂无评论