java数组

最新推荐文章于 2023-09-06 16:41:49 发布

后端包头工

最新推荐文章于 2023-09-06 16:41:49 发布

阅读量158

点赞数

分类专栏：学习笔记文章标签： java

本文链接：https://blog.csdn.net/lpy0390433/article/details/109441687

版权

学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1. 数组的概述

相同类型数组的有序集合，且每个数组都有下标。

2. 数组声明和创建

1. 数组声明创建

/*
声明数组格式中： int[] a; 等价于 int a[]（方便C用户使用）
数组赋值有：1. 静态赋值 2. 动态赋值

*/
        String[] a;//声明字符串数组，只在栈中声明了
        a = new String[3];//分配堆空间，此后可以使用和赋值
        int[] b ={0,1,2};//声明且静态赋值
        a[0]="nihao";//动态赋值
        a[1]="wohao";
        a[2]="dajiahao";
        for (int i = 0; i < 3; i++) {
            System.out.println(a[i]+" "+b[i]);
            -------------------------------------------------------
nihao 0
wohao 1
dajiahao 2

2. JAVA内存分析

java内存包括：堆、栈、方法区

1. 堆

存放new的对象和数值
可以被所有线程共享，不会存放别的对象引用

2. 栈

存放基本变量类型，包含具体值
引用对象的变量（会存放引用再堆里的具体地址）

3. 方法区

可以被所有线程共享
包含了所有class和static变量

3. 常见数组异常

java.lang.ArrayIndexOutOfBoundsException: n

数组下标越界

4. 细节

长度确定，一旦创建，大小不变，没赋值的都会被取默认值。
不能混合类型
数组任何类型，包括基本和引用

3. 数组的使用

1. 打印

public class Demo01 {
    public static void main(String[] args) {
        int[] a={0,1,2,3,4};
        printList(a);
        }
    //数组打印
    public static void printList(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
    }

2. 总和

public class Demo01 {
    public static void main(String[] args) {
        int[] a={0,1,2,3,4};
        addList(a);
        }
    public static void addList(int[] a){
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            sum +=a[i];
        }
        System.out.println(sum);
    }
    }

3. 取最值

public class Demo01 {
    public static void main(String[] args) {
        int[] a={0,1,2,50,4};
        max(a);
        }
    public static void max(int[] a){
        int sum=a[0];
        for (int i = 1; i < a.length; i++) {
            if(sum<a[i]){
                sum=a[i];
            }
        }
        System.out.println(sum);
    }
    }

4. 倒打印

public class Demo01 {
    public static void main(String[] args) {
        int[] a={0,1,2,3,4};
        printList(daoxu(a));
        }
        //倒序方法
        public static int[] daoxu(int[] a){
        int[] b =new int[a.length];//声明一个新数组装倒序
            for (int i = 0,j= a.length-1; i < a.length; i++,j--) {
                b[j]=a[i];//b的最后一个装a的第一个
            }
            return b;//返回一个数组
        }
        //数组打印
    public static void printList(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
    }

5. 增强for循环 for-each循环

public class Demo01 {
    public static void main(String[] args) {
        int[] a={0,1,2,3,4};
        for (int i : a) {
            System.out.println(i);
        }
        }
    }

6. 排序（冒泡排序）

    public static void main(String[] args) {
        int[] a={3,1,2,4,5};
        //得出数组长度，循环比较多少次
        for (int i = 0; i < a.length-1; i++) {
            for(int j = 0;j < a.length-1-i;j++){
                if(a[j+1]<a[j]){
                    int b =a[j+1];
                    a[j+1]=a[j];
                    a[j]=b;
                }

            }
        }
        System.out.println(Arrays.toString(a));
    }

4. 多维数组

1. 简介

public class Demo01 {
    public static void main(String[] args) {
        int[][] a = {{1, 1}, {2, 1}, {3, 1}, {4, 1}};//二维数组
        //第一层循环，理解为外面{}的循环
        for (int[] ints : a) {
            //第二层循环，理解为内部{}中的循环
            for (int anInt : ints) {
                System.out.print(anInt+"\t");//小{}输出+制表符
            }
            System.out.println();//每输出一个小{}换行
        }

    }
}

2. 细节

public class Demo01 {
    public static void main(String[] args) {
        int[][] a = {{1, 1}, {2, 1}, {3, 1}, {4, 1}};
        System.out.println(a[0]);
        System.out.println(a[0][0]);
    }
}
---------------------------------------
[I@4554617c   //代表第一个小{}的地址
1

5. Arrays类

1. Arrays类常用方法

1. 打印

public class Demo01 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5};
        //用Arrays工具包中的toString方法打印数组
        System.out.println(Arrays.toString(a));
    }
}
-------------------------------------------
[1, 2, 3, 4, 5]

2. 排序

public class Demo01 {
    public static void main(String[] args) {
        int[] a={3,1,2,4,5};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);//把a数组排序
        System.out.println(Arrays.toString(a));
    }
}
------------------------------------------
[3, 1, 2, 4, 5]
[1, 2, 3, 4, 5]

3. 比较数组

equals()

4. 二分法查找数组元素

binarySearch()

2. 如何查看JDK帮助文档

打开jdk 帮助文档搜索查看
在IDEA中 crtl+鼠标左键点击某类 +structure查看结构既有很多方法。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jlQwMqu6-1604275912841)(D:\学习资料\学习资料@@@@正在学@@@@@\JAVA学习\picture\11.jpg)]$

6. 稀疏数组

稀疏数组是一种数据结构。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fmpCxZQK-1604275912846)(D:\学习资料\学习资料@@@@正在学@@@@@\JAVA学习\picture\12.jpg)]

格式：

1.
    int[][] a = new int[有用数据+1][3];//+1是为了记录原始数组的行列
2.
        a2[0][0]=11;
        a2[0][1]=11;
        a2[0][2]=sum; //有用数据数量
3.

public class Sparse {
    public static void main(String[] args) {
        int[][] a = new int[11][11];
        a[1][2]= 1;
        a[2][3]= 1;
        int sum=0;
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt);
                if(anInt!=0)
                {
                    sum++;
                }
            }
            System.out.println();
        }
        System.out.println("=============");
/*
稀疏数组存值
*/
        //稀疏数组 a2 sum=原始数组中存放的数据 3为固定
        int[][] a2 = new int[sum+1][3];
        //存放数组基本情况 11行11列sum个数值
        a2[0][0]=11;
        a2[0][1]=11;
        a2[0][2]=sum;
        int count = 0;//记录数据位置
        //遍历原数组
        for(int i = 0; i<a.length;i++){
            for(int j =0; j<a[i].length;j++){
                //若不等于0，即存下数据
                if(a[i][j]!=0){
                    //count++ 为1 即为记录的一个不为0的数据
                count++;
                a2[count][0]=i;
                a2[count][1]=j;
                a2[count][2]=a[i][j];
            }
            }
        }
        for (int[] ints : a2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=============");
/*
稀疏数组还原
*/
        int[][] a3 = new int[a2[0][0]][a2[0][1]];
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]]=a2[i][2];
        }
        for (int[] ints : a3) {
            for (int anInt : ints) {
                System.out.print(anInt);
            }
            System.out.println();
        }
    }
}
---------------------------------------
00000000000
00100000000
00010000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000    原表
=============
11	11	2	
1	2	1	   稀疏数组
2	3	1	
=============
00000000000
00100000000
00010000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000   稀疏数组还原

后端包头工

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java数组

1. 数组的概述相同类型数组的有序集合，且每个数组都有下标。2. 数组声明和创建1. 数组声明创建/*声明数组格式中： int[] a; 等价于 int a[]（方便C用户使用）数组赋值有：1. 静态赋值 2. 动态赋值*/ String[] a;//声明字符串数组，只在栈中声明了 a = new String[3];//分配堆空间，此后可以使用和赋值 int[] b ={0,1,2};//声明且静态赋值 a[0]="nihao
复制链接

扫一扫

专栏目录