javaSE-数组

目录

一.概述

二.应用场景

三.数组声明

1.静态声明

2.动态声明

3.数组传递(第三种声明方式,静态声明)

四.基本操作

1.获取长度

2.设置数据

3.遍历

五.常见异常

六.传值和传引用

七.API

八.二维数组

1.声明

2.使用

九.Scanner类

十.排序

1.交换两个变量的值

2.冒泡排序

3.选择排序

4.使用API


一.概述

数组:

是引用数据类型(类,数据,接口),

数组可以用来存储多个相同类型的数据,

数组是线性的数据结构,

数组的长度不可更改

数组中有一个length属性保存了数组的长度

下表从0开始

数组占用两块空间,栈内存变量保存堆内存引用

数组是底层的数据结构,几乎任何语言都有.

分类:

​ 索引数组(目前只涉及索引数组)

​ 关联数组

数据结构:

就是存储和管理数据的方式,有数组,栈,链表,散列,二叉树/红黑树

二.应用场景

数组:方便查询和修改,但是不方便添加删除

链表:添加删除效率高,查询更改效率低

三.数组声明

1.静态声明

知道数组中的每个元素的值的时候,使用静态声明的方式

数据类型[] 变量 = {值,值,…};

例如:

int[] i = {1,2,3,4,5};
int[][] j = {{1,2,3},{1,2,3},...};

2.动态声明

在预知不知道每个元素值是多少的时候动态声明,需要提前指定数组的长度,并使用默认值占位

整数:0

浮点:0.0

char:\u0000

boolean:false

引用数据类型:null

数据类型[] 变量 = new 数据类型[长度];

例如:

int[] is = new int[10];

3.数组传递(第三种声明方式,静态声明)

语法:

数据类型[] 变量 = new 数据类型[]{值,值,值,…};

例子:

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

四.基本操作

1.获取长度

int[] a = {1,2,3,4};
int len = a.length;//获取a的长度

2.设置数据

int[] a = {1,2,3,4};
a[0] = 5;//将数组中的第一个元素的值修改为5

3.遍历

int[] a = {1,2,3,4};
for(int i = 0;i<a.length;i++){
    System.out.println(a[i]);
}
//增强for循环
for(int i: a){
    System.out.println(i);
}    

五.常见异常

下标越界异常

java.lang.ArrayIndexOutofBoundsException

空指针异常

java.lang.NullPointerException

六.传值和传引用

传值:基本类型传递

传递的是值的副本。方法中对副本的修改,不会影响到调用方。

引用:引用类型传递

传递的是引用的副本,共用一个内存,会影响到调用方。此时,形参和实参指向同一个内存地址。对引用副本本身(对象地址)的修改,如设置为null,重新指向其他对象,不会影响到调用方。

代码示例:

public class Test {
    public static void main(String[] args) {
        int i = 10;
        m1(i);
        System.out.println(i);
        System.out.println("_______");
        int[] arr = {1,2,3,4,5};
        m2(arr);
        for(int j = 0;j<arr.length;j++){
            System.out.println(arr[j]);
        }
        
    }
    public static void m1(int i){
        i = 20;
        System.out.println(i);
    }
    public static void m2(int[] i){
        i[0] = 20;
        for(int j = 0;j<i.length;j++){
            System.out.println(i[j]);
        }
    }
}

小练习1:

实现数组替换式复制:

需求:把a数组的某些数据复制到b数组中,并替换指定数据

a = {1,2,3,4,5,6};

b = {11,12,13,14,15,16};

复制操作

b = {11,2,3,4,15,16};

public class Test02 {
    public static void main(String[] args) {
        int[] src = { 1, 2, 3, 4, 5, 6 };
        int[] dest = { 11, 12, 13, 14, 15, 16 };
        // arrayCopy(src, 1, dest, 2, 3);
        // 源数组,起始索引(包含),目标数组,起始索引(包含) , 复制个数 
        System.arraycopy(src, 1, dest, 2, 3);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }
/**
     * 数组替换式复制
     * 
     * @param src
     *            源数组
     * @param srcPos
     *            源数组起始位置(包含)
     * @param dest
     *            目标数组
     * @param destPos
     *            目标数组起始位置(包含)
     * @param length
     *            复制个数
     *            
     *           因为传引用,并且也没有更改dest的长度,所以不需要返回值
     */
    public static void arrayCopy(int[] src, int srcPos, int[] dest,int destPos, int length) {
        for(int i = 0;i<length;i++){
            dest[destPos++] = src[srcPos];
        }
    }
}

小练习2:

实现数组插入式复制

思路:

 

public class Test03 {
    public static void main(String[] args) {
        int[] src = { 1, 2, 3, 4, 5, 6 };
        int[] dest = { 11, 12, 13, 14, 15, 16 };
        int[] result = arrayCopy(src, 1, dest, 2, 3);
        for(int i:result){
            System.out.println(i);
        }
    }
    /**
     * 数组替换式复制
     * 
     * @param src
     *            源数组
     * @param srcPos
     *            源数组起始位置(包含)
     * @param dest
     *            目标数组
     * @param destPos
     *            目标数组起始位置(包含)
     * @param length
     *            复制个数
     *            
     */
    public static int[] arrayCopy(int[] src, int srcPos, int[] dest,int destPos, int length){
        //首先创建一个数组:数组长度 = dest.length+length
        boolean flag = true;
        int[] newArray = new int[dest.length+length];
        for(int i = 0;i<newArray.length;i++){
            if(i == destPos+1){
                for(int j = 0;j<length;j++){
                    newArray[i] = src[srcPos++];
                    if(j<length-1){
                        i++;
                    }
                    
                }
                flag = false;
                
            }else{
                if(flag){
                    newArray[i] = dest[i];
                }else{
                    newArray[i] = dest[i-length];
                }
            }
            
            
        }
        return newArray;
    }
}

七.API

并不是所有的功能都需要自己去编写,很多功能已经写好了,直接调用就好了

例如:

System.arraycopy(src, 1, dest, 2, 3);

八.二维数组

1.声明

静态声明

int[][] arr = {
    {1,2,3},
    {11,12,13},
    {0},
    {10,21,11,34,99}
}

动态声明

int[][] arr = new int[5][3];
//二维数组中有五个一维数组,每个一维数组有三个元素
int[][] arr = new int[5][];
二维数组中有五个一维数组,每个一维数组都是空,需要单独对每一个一维数组进行设置

2.使用

int[][] arr = {
    {1,2,3},
    {11,12,13},
    {0},
    {10,21,11,34,99}
}
//获取第一个一维数组
int[] arr0 = arr[0];
//第一个数组的第一个元素
int a = arr[0][0];
//遍历二维数组
for(int i = 0;i<arr.length;i++){
    for(int j = 0;j<arr[i].length;j++){
        System.out.pritln(arr[i][j]);
    }
}

九.Scanner类

接收用户输入

Scanner s = new Scanner(System.in);

public class Array_12_Scanner {

    public static void main(String[] args) {
        // 接收用户输入
        Scanner s = new Scanner(System.in);

        // 程序执行到这里,就会进入等待状态,等待用户输入
        // 并把输入的数据,返回,并赋值给变量userInput
        // 多个数据以空格隔开
        // String userInput = s.next();
        // System.out.println(userInput+"-------");

        // 接收一行数据,不需要分隔符
        // String userInput = s.nextLine();
        // System.out.println(userInput);
        
        // 接收整型,必须是纯数字,小数点也不行   java.util.InputMismatchException
        // int userInput = s.nextInt();
        // System.out.println(userInput);
        
        // 接收小数,可以有一个小数点
        double userInput = s.nextDouble();
        System.out.println(userInput);
    }
}

十.排序

1.交换两个变量的值

方法一:

中间变量(开发常用)

int x = 10;
int y = 20;

int temp = x;
x = y;
y = temp;
System.out.println(x+" : "+y);

方法二:

位移运算(面试常用)

// 转换为对应的二进制,然后每位进行异或 , 相同为0 不同为1
// 0010
// 0011
x = 2;
y = 3;
x = x ^ y;
// 0001
// 0011
y = x ^ y;
// 0001
// 0010
x = x ^ y;
// 0011
// 0010
System.out.println(x+" : "+y);

方法三:

加减运算

x = 10;
y = 20;
x = x + y;
y = x - y;
x = x - y;
System.out.println(x+" : "+y);

2.冒泡排序

1 比较相邻的两个元素,如果第一个比第二个大,就交换位置
2 对每一对相邻的元素做 相同的比较工作,这样比较完一轮之后,最后一个元素一定是最大的
3 再重复执行上面的步骤,除了最后一个元素(比较次数依次递减)
4 一直到没有任何一对元素,终止

嵌套循环
1 外层循环决定比较多少轮
2 内存循环决定每轮比较多少次

public static void main(String[] args) {
    int[] arr = {1,5,4,2,3};
    bubbleSort(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
public static void bubbleSort(int[] arr){
    int count = 0;
    for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j < arr.length-1-i ; j++) {
            count++;
            if (arr[j] < arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        // 1,5,4,2,3
        // 5,4,2,3,1  i=0,j=3
        // 5,4,3,2,1  i=1,j=2
        // 5,4,3,2,1  i=2,j=1
        // 5,4,3,2,1  i=3,j=0
    }
    System.out.println("执行了 : "+count);
}

3.选择排序

每次都把当中最小的放到左边

先拿出第一个,假设是最小的,然后挨个和后面所有比较,全部比较完之后,就找到了最小的元素,放到前面

public static void main(String[] args) {
    int[] arr = {1,5,4,2,3};
    selectSort(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

public static void selectSort(int[] arr){
    for (int i = 0; i < arr.length; i++) {
        // min 是最小的元素下标,默认假设 i 就是最小的
        int min = i;
        for (int j = i+1; j < arr.length; j++) {
            // 有比min还小的,就把下标赋值给min
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        // 1,5,4,2,3  i = 0 , min = 0,i=0 , j=4
        // 5,1,4,2,3  i = 0 , min = 0 ,i=1, j=4
        // 5,4,1,2,3  i = 0 , min = 1 ,i=2, j=4
        // 5,4,2,1,3  i = 0 , min = 2 ,i=3, j=4
        // 5,4,2,3,1  i = 0 , min = 3 ,i=4, j=4
        // 判断i是否是最小的
        // 只要 min 不等于 i 说明 有比i小的
        if (min != i) {
            int temp = arr[min];
            arr[min] = arr[i];
            arr[i]=temp;
        }
    }

4.使用API

public static void main(String[] args) {
    int[] arr = {1,5,4,2,3};
    Arrays.sort(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mizui_i

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值