java 下标排序数组 java数组下标的数据类型

转载

footballboy 2023-09-10 12:41:32

文章标签 java 下标排序数组 java 数组 System 一维数组 文章分类 Java 后端开发

一.数组

1.一维数组

含义：一组数据的容器

作用：存储多个数据

数组的声明：

数据类型[] 数组名/变量名；

注意：

数组是引用数据类型
数组中的数据，称之为元素
每个元素都有编号，称之为下标/索引
下标从0开始
下标的作用：通过下标可以定位到数组中的某个位置
数组一旦初始化成功，长度将不可改变
操作数组：
改 - 通过下标设置元素
查 - 通过下标获取元素
查 - 获取元素个数
查 - 遍历数组

数组的初始化：

静态初始化：数据由程序员给定，长度由系统分配

public class Test{
	public static void main(String[] args){
	
		//静态初始化一
		//String[] names = new String[]{"AA","BB","CC","DD","EE"};
		
		//静态初始化二(先声明再初始化)
		//String[] names;
		//names = new String[]{"AA","BB","CC","CC","DD"};
		
		//静态初始化三（简化写法1）
		String[] names = {"AA","BB","CC","DD","EE"};
		
		//通过下标设置元素
		names[2] = "FF";
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//下标从0开始，不超过数组的长度
		//names[5] = "xxx";
		
		
		//通过下标获取元素
		String str = names[2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取元素个数
		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 element : names){//依次将元素赋值给element
			System.out.println(element);
		}
		
		/**
			for vs foreach
				遍历时，使用到下标 -- for
				遍历是，不使用下标 -- foreach
		*/
		
	}
	
}

动态初始化:
长度由程序员给定，数据由系统分配默认值
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null（空）

public class Test{
	public static void main(String[] args){
	
		//动态初始化一
		//String[] names = new String[5];//5-数组的的长度
		
		//动态初始化二(先声明再初始化)
		String[] names;
		names = new String[5];
		
		//通过下标设置元素
		names[0] = "AA";
		names[1] = "BB";
		names[2] = "CC";
		names[3] = "DD";
		names[4] = "EE";
		
		//ArrayIndexOutOfBoundsException - 数组下标越界异常
		//下标从0开始，不超过数组的长度
		//names[5] = "xxx";
		
		
		//通过下标获取元素
		String str = names[2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取元素个数
		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 element : names){//依次将元素赋值给element
			System.out.println(element);
		}
		
		/**
			for vs foreach
				遍历时，使用到下标 -- for
				遍历是，不使用下标 -- foreach
		*/
		
	}
	
}

一维数组的应用：
需求：创建一个int数组，长度让用户指定，数据有用户输入，获取数组中的最大值

import java.util.Scanner;
public class Test{
	public static void main(String[] args){
	
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入数组的长度：");
		int len = scan.nextInt();
		
		if(len <= 0){
			System.out.println("长度有误~~");
			return;
		}
	
		//动态初始化数组
		int[] is = new int[len];
		
		//循环输入
		for(int i = 0;i<is.length;i++){
			System.out.println("请输入第" + (i+1) + "个数字：");
			int num = scan.nextInt();
			is[i] = num;
		}
		
		//获取数组中的最大值
		
		int max = is[0];//假设数组第一个元素为最大值
		for(int i = 1;i<is.length;i++){
			if(max < is[i]){
				max = is[i];
			}
		}	
		System.out.println("最大值为：" + max);	
	}	
}

1.1 冒泡排序

public class Test{
	/**
        N个数字来排队
        两辆相比小靠前
        外层循环N-1
        内层循环N-1-i
	*/
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		for(int i = 0;i<nums.length-1;i++){
			for(int j = 0;j<nums.length-1-i;j++){
				if(nums[j] > nums[j+1]){
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		
		for(int element : nums){
			System.out.println(element);
		}
		
	}
	
	
}

1.2 线性查找/顺序查找

public class Test{
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		int num = 18;//需要查找的值
		
		for(int i = 0;i<nums.length;i++){
			if(nums[i] == num){
				System.out.println("找到元素了，下标为：" + i);
				break;
			}
		}
	}
	
	
}

1.3 二叉查找/二分法查找

import java.util.Arrays;
public class Test{
	/**
		知识点：数组的查找 -- 二叉查找/二分法查找
		
		注意：必须先排序
		
	*/
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		int num = 18;//需要查找的值
		
		//数组的排序 -- 9,18,23,33,56,81
		Arrays.sort(nums);
		
		int start = 0;
		int end = nums.length-1;
		
		while(start <= end){
			int mid = (start+end)/2;
			
			if(nums[mid] > num){
				end = mid-1;
			}else if(nums[mid] < num){
				start = mid+1;
			}else{
				System.out.println("找到元素了，下标为：" + mid);
				break;
			}
			
		}
		
	}

}

1.4 数组的复制

public class Test{
	/**
		知识点：数组的复制1
		
		缺点：修改源数组，新数组也会发生改变
		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};
		
		//新数组
		String[] newNames = names;
		
		//修改源数组的数据
		names[1] = "EE";
		
		//遍历新数组
		for(String str : newNames){
			System.out.println(str);
		}
		
	}
}public class Test{
	/**
		知识点：数组的复制2		
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};
		
		//新数组
		String[] newNames = new String[names.length];
		
		//数据的复制
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
		
		//修改源数组的数据
		names[1] = "EE";
		
		//遍历新数组
		for(String str : newNames){
			System.out.println(str);
		}
		
	}
}

1.5 数组的扩容

public class Test{
	/**
		知识点：数组的扩容	

		扩容机制：原来长度的1.5
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};
		
		//老的长度
		int oldCapacity = names.length;
		//新的长度
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		
		//创建新数组
		String[] newNames = new String[newCapacity];
		
		//将源数组的数据复制到新数组中
		for(int i = 0;i<names.length;i++){
			newNames[i] = names[i];
		}
		
		//将新数组的地址复制给源数组
		names = newNames;
		
		//遍历源数组
		for(String str : names){
			System.out.println(str);
		}		
	}
}

1.6 数组的删除

public class Test{
	/**
		知识点：数组的删除1
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};//0,1,2,3
		
		//创建新数组
		String[] newNames = new String[names.length-1];//0,1,2
		
		//遍历源数组，将除了"BB"的元素都放入新数组中
		int index = 0;
		for(String element : names){
			if(!element.equals("BB")){
				newNames[index++] = element;
			}
		}
		
		//将新数组的引用复制给原数组
		names = newNames;
		
		//遍历源数组
		for(String element : names){
			System.out.println(element);
		}
	}
}public class Test{
	/**
		知识点：数组的删除2
	*/
	public static void main(String[] args){
		
		//源数组
		String[] names = {"AA","BB","CC","DD"};//0,1,2,3
		
		//数据的迁移
		for(int i = 1;i<names.length-1;i++){
			names[i] = names[i+1];
		}
		
		//把最后一个元素置为null
		names[names.length-1] = null;
		
		//遍历源数组
		for(String element : names){
			System.out.println(element);
		}
	}
}

2. Arrays工具类——专门操作数组的工具类

Simport java.util.Arrays;
public class Test11{
	/**
		知识点：Arrays工具类
		含义：Java给我们提供的专门操作数组的工具类
		
		工具类的概念：该类中所有的方法都是静态的，直接使用类名调用
		API的概念：Java提供类的说明书（放在桌面去，方便我们查询）
		
	*/
	public static void main(String[] args){
		
		int[] nums = {81,23,56,18,33,9};
		
		//排序 -- 9,18,23,33,56,81
		Arrays.sort(nums);
		
		//查找
		//返回值：搜索键的索引，如果它包含在数组中;否则， (-(insertion point) - 1) 
		//返回值：如果查找的值在数组中，就返回下标;否则，返回(-插入点-1)
		int index = Arrays.binarySearch(nums,40);
		System.out.println("查找元素的下标为：" + index);
		
		//拷贝数组(目标数组,新的长度)
		int[] arr1 = Arrays.copyOf(nums,nums.length*2);
		
		//拷贝数组(目标数组,开始下标-包含,结束下标-不包含)
		int[] arr2 = Arrays.copyOfRange(arr1,2,8);
		
		//替换(目标数组,要替换的值)
		Arrays.fill(arr2,888);
		
		//替换(目标数组,开始下标-包含,结束下标-不包含,要替换的值)
		Arrays.fill(arr2,1,4,666);
	
		//将数组转换为字符串 -- [23,33,56,81,0,0]
		System.out.println(Arrays.toString(arr2));
	}
}

2.二维数组

2.1 静态初始化

public class Test{
	/**
		知识点：二维数组
		
		含义：包含了多个一维数组
		
		数组的声明：
			数据类型[][] 数组名;

	*/
	public static void main(String[] args){
		
		//静态初始化一
		//String[][] names = new String[][]{{"AA","BB","CC"},{"DD","EE","FF","GG"}};
		
		//静态初始化二(先声明，再初始化)
		//String[][] names;
		//names = new String[][]{{"AA","BB","CC"},{"DD","EE","FF","GG"}};
		
		//静态初始化三(简化写法一)
		String[][] names = {{"AA","BB","CC"},{"DD","EE","FF","GG"}};
		
		//设置指定下标上的元素
		names[1][1] = "NN";
		
		//获取指定下标上的元素
		String str = names[1][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		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[] ss : names){
			for(String element : ss){
				System.out.println(element);
			}
		}
	
	}
}

2.2 动态初始化

public class Test{
	/**
		知识点：二维数组
		
		含义：包含了多个一维数组
		
		数组的声明：
			数据类型[][] 数组名;

	*/
	public static void main(String[] args){
		
		//动态初始化一
		//String[][] names = new String[2][3];//2-创建2个一维数组  3-每个一维数组有3个元素
		
		//动态初始化二（先声明，再初始化）
		String[][] names;
		names = new String[2][3];//2-创建2个一维数组  3-每个一维数组有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 str = names[1][1];
		System.out.println("获取指定下标上的元素：" + str);
		
		//获取长度
		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[] ss : names){
			for(String element : ss){
				System.out.println(element);
			}
		}
	
	}
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Arm架构大数据优势 arm架构risc

下一篇：android 需要什么证书安卓有什么证书

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java 下标排序 数组 java数组下标的数据类型

java 下标排序 数组 java数组下标的数据类型

一.数组

1.一维数组

1.1 冒泡排序

1.2 线性查找/顺序查找

1.3 二叉查找/二分法查找

1.4 数组的复制

1.5 数组的扩容

1.6 数组的删除

2. Arrays工具类——专门操作数组的工具类

2.二维数组

2.1 静态初始化

2.2 动态初始化

51CTO博客

java 下标排序数组 java数组下标的数据类型

java 下标排序数组 java数组下标的数据类型