Java关于数组基础的讲解

本文主要是介绍Java关于数组基础的讲解，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、数组

1.一维数组

概念：一组数据的容器（数组可以存放多个数据）
注意：
1.数组是引用数据类型
2.数组中的数据又叫做元素
3.每个元素都有编号叫做下标/索引
4.下标从0开始
5.数组初始化后，会在内存中开辟一连串连续的空间
6.数组一旦初始化后长度不可以改变（数组没有扩容和删除）
7.数组的操作：添加、修改、查询
数组的声明：数据类型[] 数组名;
数组的初始化：
静态初始化：数据由程序员指定，长度由系统分配
动态初始化：长度由程序员指定，数据由系统分配(默认值)

整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null(空)

遍历 - for循环
遍历 - foreach(增强for循环)
遍历时要使用到下标，就用for循环遍历
遍历时要不使用到下标，就用foreach遍历

静态初始化：数据由程序员指定，长度由系统分配
public class Test09{
	
	public static void main(String[] args){
		
		//静态初始化1
		//String[] names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
		
		//静态初始化2
		//String[] names;
		//names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
		
		//静态初始化3
		String[] names = {"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
        
		//设置指定下标上的元素
		names[3] = "aa";
		//获取指定下标上的元素
		String n = names[3];
		System.out.println("获取指定下标上的元素：" + n);//
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//System.out.println(names[100]);
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		System.out.println("-----------");
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		System.out.println("-----------");
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}
		for(String s:names){
			System.out.println(s);
		}
	}
}
动态初始化：长度由程序员指定，数据由系统分配(默认值)
public class Test10{

	public static void main(String[] args){
		
		//动态初始化1
		String[] names = new String[5];//5->5个长度
		//设置指定下标上的元素
		names[0] = "aa";
		names[1] = "bb";
		names[2] = "cc";
		names[3] = "dd";
		names[4] = "ee";
		//获取指定下标上的元素
		String n = names[3];
		System.out.println("获取指定下标上的元素：" + n);//
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//System.out.println(names[100]);
		//获取元素个数
		int len = names.length;
		System.out.println("获取元素个数：" + len);//5
		
		System.out.println("-----------");
		
		//遍历 - for循环
		for(int i = 0;i<names.length;i++){
			System.out.println(names[i]);
		}
		System.out.println("-----------");
		//遍历 - foreach(增强for循环)
		for(String str:names){//遍历数组，依次把元素赋值给str
			System.out.println(str);
		}
	}
}

1.1 静态初始化和动态初始化

静态初始化 vs 动态初始化
一开始就知道数据：静态初始化
一开始就知道长度：动态初始化

1.2 数组的排序—冒泡排序

口诀：
N个数字来排序
两两相比小靠前
外层循环N-1
内层循环N-1-i

public class Test01{
	
	public static void main(String[] args){
		
		int[] is = {39,77,27,20,45,62};
		
		for(int i = 0;i<is.length-1;i++){
			for(int j = 0;j<is.length-1-i;j++){
				if(is[j] > is[j+1]){
					int temp = is[j];
					is[j] = is[j+1];
					is[j+1] = temp;
				}
			}
		}
		for(int num : is){
			System.out.println(num);
		}
	}
}

1.3 数组的查找

1.3.1 顺序查找

顺序查找：从头到尾遍历

public class Test02{

	public static void main(String[] args){
		int[] is = {39,77,27,20,45,62};
        int num = 77;
        for(int i = 0;i<is.length;i++){
            if(is[i] == num){
                System.out.println("查找到了");
            }
        }	
	}
}

1.3.2 二分查找

前提：先排序

import java.util.Arrays;
public class Test02{

	public static void main(String[] args){
		
		int[] is = {39,77,27,20,45,62};
		int num = 77;
		//排序
		Arrays.sort(is);
		int start = 0;
		int end = is.length-1;
		while(start <= end){
			int mid = (start+end)/2;
			if(num >is[mid]){
				start = mid+1;
			}else if(num < is[mid]){
				end = mid-1;
			}else{
				System.out.println("查找到了");
				break;
			}
		}
	}
}

1.4 数组的复制

第一种方法：new一个新数组，直接将原数组的地址赋值给新数组

缺点：修改原数组，新数组的数据也随之改变

public class Test03{
	
	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		String[] newNames = names;
		
		//修改原数组
		names[0] = "三上悠亚";
		
		//遍历新数组
		for(String name : newNames){
			System.out.println(name);
		}
	}
}

第二种方法：new一个新数组，将原数组中的数据复制给新数组，此时修改原数组，新数组中的数据不会改变

public class Test04{
	
	public static void main(String[] args){
		
		//源数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		String[] newNames = new String[names.length];
		
		//将原数组中数据依次赋值给新数组
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
	
		//修改原数组
		names[0] = "三上悠亚";
		
		//遍历新数组
		for(String name : newNames){
			System.out.println(name);
		}
	}
}

1.5 数组的扩容

public class Test05{

	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		int capacity = names.length + (names.length>>1);//新容量：是原数组长度的1.5倍
		String[] newNames = new String[capacity];
		
		//把原数组所有的数据迁移到新数组中
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
		
		//将新数组的地址赋值给原数组
		names = newNames;
		
		//遍历原数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

1.6 数组的删除

第一种方法：创建新数组将除了要删除的数据其他的数据赋值给新数组

缺点：数组原本是存放数据的，删除元素后，数组长度变短

public class Test06{

	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//新数组
		String[] newNames = new String[names.length-1];
		
		//将原数组的数据迁移到新数组中，要删除的元素(深田咏美)除外
		int index = 0;//新数组的下标
		for(String name:names){
			if(!name.equals("深田咏美")){
				newNames[index] = name;
				index++;
			}
		}
		
		//将新数组的地址赋值给原数组
		names = newNames;
		
		//遍历原数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

第二种方法：将后面的数据依次往前覆盖然后给最后一个数据赋值null

public class Test07{
	
	public static void main(String[] args){
		
		//原数组
		String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
		
		//数据的迁移
		for(int i = 1;i<names.length-1;i++){
			names[i] = names[i+1];
		}
		names[names.length-1] = null;
		
		//遍历原数组
		for(String name:names){
			System.out.println(name);
		}
	}
}

1.7 数组的参数和返回值

public class Test08{
	
	//需求：设计一个方法，传入数组，返回最大值和最小值
	public static void main(String[] args){
		
		int[] is = {1,2,3,4,5,6};
		
		int[] newArr = method(is);
		System.out.println("最大值为：" + newArr[0]);
		System.out.println("最小值为：" + newArr[1]);
	}
	
	public static int[] method(int[] is){
		int max = is[0];
		int min = is[0];
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
			if(min > is[i]){
				min = is[i];
			}
		}
		return new int[]{max,min};
	}
}

1.8 可变参数

public class Test09{
	
	//需求：设计一个方法，传入五个int值，求和
	public static void main(String[] args){
		
		int sum = add(1,2,3,4,5,6,7);//实参作为元素，压入到数组中
		System.out.println(sum);
	}
	
	//is就是数组
	public static int add(int... is){
		int sum = 0;
		for(int num : is){
			sum += num;
		}
		return sum;
	}
	//注意：可变参数后不能接其他参数 
    //错误
	public static void method(int a,String... ss){}
}

2.Arrays工具类

import java.util.Arrays;
public class Test11{	
	/**
		知识点：Arrays工具类
		Arrays：java给我们提供的专门操作数组的工具类
		工具类：类里的所有方法都是静态的（直接使用类名调用）
		API：java类的使用说明书
	*/
	public static void main(String[] args){
		
		int[] is = {39,77,27,20,45,62};
		
		//排序: 20 27 39 45 62 77
		Arrays.sort(is);
		
		//查找(返回值：如果元素在数组中就返回下标，否则返回 -插入点-1 )
		int index =  Arrays.binarySearch(is,42);
		System.out.println("查找元素的下标为：" + index);
		
		//替换
		Arrays.fill(is,888);
		Arrays.fill(is,1,4,666);
		
		//拷贝
		int[] copyOf = Arrays.copyOf(is,is.length*2);
		int[] copyOfRange = Arrays.copyOfRange(is,3,8);
		
		//获取数组的字符串表示(将数组转换为字符串)
		System.out.println(Arrays.toString(copyOfRange));
	}
}

3.二维数组

含义：包含了多个一维数组
声明：数据类型[][] 数组名;
数组的初始化：
静态初始化：数据由程序员指定，长度由系统自动分配

public class Test01 {
    public static void main(String[] args) {

        //静态初始化1
        //String[][] names = new String[][]{{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};

        //静态初始化2
        //String[][] names;
        //names = new String[][]{{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};

        //静态初始化3
        String[][] names = {{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};
        //设置指定下标上的元素
        names[0][2] = "山上悠亚";

        //获取指定下标上的元素
        String name = names[0][2];
        System.out.println("获取指定下标上的元素：" + name);

        //获取长度
        System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
        System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
        System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4

        System.out.println("------------");

        //遍历 - for循环
        for (int i = 0; i < names.length; i++) {
            for (int j = 0; j < names[i].length; j++) {
                System.out.println(names[i][j]);
            }
        }
        System.out.println("------------");

        //遍历 - foreach
        for (String[] strings : names) {
            for (String string : strings) {
                System.out.println(string);
            }
        }
    }
}

动态初始化：长度由程序员指定，数据由系统赋默认值

public class Test02 {

	public static void main(String[] args) {
		
		//动态初始化1
		//String[][] names = new String[2][3];//2个一维数组，每个一维数组中有3个元素
		
		//动态初始化2
		String[][] names;
		names = new String[2][3];//2个一维数组，每个一维数组中有3个元素
		
		//设置指定下标上的元素
		names[0][0] = "aa";
		names[0][1] = "bb";
		names[0][2] = "cc";
		names[1][0] = "dd";
		names[1][1] = "ee";
		names[1][2] = "ff";
		
		//获取指定下标上的元素
		String name = names[0][2];
		System.out.println("获取指定下标上的元素：" + name);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4
		
		System.out.println("------------");
		
		//遍历 - for循环
		for (int i = 0; i < names.length; i++) {
			for (int j = 0; j < names[i].length; j++) {
				System.out.println(names[i][j]);
			}
		}
		
		System.out.println("------------");
		
		//遍历 - foreach
		for (String[] strings : names) {
			for (String string : strings) {
				System.out.println(string);
			}
		}
	}
}

需求：使用动态初始化二维数组，其中第一个一维数组有3个元素，第二个一维数组有4个元素

public class Test03 {
    public static void main(String[] args) {
        //动态初始化：标注二维数组中有2个一维数组
        String[][] names = new String[2][];

        //把长度为3的一维数组赋值给二维数组中下标为0的位置
        names[0] = new String[3];
        //把长度为4的一维数组赋值给二维数组中下标为1的位置
        names[1] = new String[4];

        System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
        System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
        System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4
    }					
}

这篇关于Java关于数组基础的讲解的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

Java关于数组基础的讲解

一、数组

1.一维数组

1.1 静态初始化和动态初始化

1.2 数组的排序—冒泡排序

1.3 数组的查找

1.3.1 顺序查找

1.3.2 二分查找

1.4 数组的复制

1.5 数组的扩容

1.6 数组的删除

1.7 数组的参数和返回值

1.8 可变参数

2.Arrays工具类

3.二维数组

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯