06数组

最新推荐文章于 2023-06-11 17:37:10 发布

勋大大

最新推荐文章于 2023-06-11 17:37:10 发布

阅读量128

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/weixin_44962092/article/details/95075973

版权

JAVA 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

数组

数组的概念

 概念：数组是内存中的一块 连续的 存储空间 用于存放 多个 类型相同 的数据 是数据存储的一个容器

变量 只能存放一个值
数组 可以存放多个类型相同的值

数组的定义

1.数组的声明：确定了数组是用于存放什么类型的数据
	语法：
	数据类型[]  数组名；//建议
	数据类型  []数组名；
	数据类型 数组名[]；//c语言的写法
2.为数组开辟空间：确定了数组可以存放多少个数据
	语法：
	数组名 = new 数据类型[数组的长度（容量）]；
案例：
	//声明
	int[] a;
	//开辟空间
	a = new int[5];

数组的属性
	元素：数组的存储数据的一小快的空间 类似于一个变量  可以通过下标访问 语法：数组名[下标]
	下标：数组会为每个元素分配一个下标便于访问每个元素  范围：0--- a.length-1
	数组的长度：数组名.length 可以动态的获取数组长度

总结一下数组定义的方式
第一种：先声明  开辟空间（直接为数组分配空间 而没有存放数据）隐式初始化
	1.先声明 后开辟空间
		语法：
		int[] a;
		a = new int[4];
	2.声明的同时并开辟空间
		语法：
		int[] a = new int[4];
第二种：声明 为数组元素赋值（显式初始化）
	1.先声明  后为数组赋值
		语法：
		int[] a;
		a = new int[]{1,4,6,7,8,8};
	2.声明的同时并赋值
		int[] a = new int[]{1,4,6,7,8,8};
		简写：
		int[] a = {1,4,6,7,8,8};
		以下写法是错误的  简写形式 声明和赋值必须是同一条语句
		int[] a ;
		a = {1,4,6,7,8,8};//错误
		注意：不能在赋值的同时又为数组定义长度
		int[] a = new int[5]{1,2,3,4,5};

数组的使用

存数据
取数据
案例：
public class Demo{
	public static void main(String[] args) {
		//声明
		int[] a;
		//分配空间
		a = new int[3];

		//存数据 数组名[下标]
		a[0] = 3;
		a[1] = 6;
		a[2] = 9;

		//取数据  访问每个元素
		System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		//获得数组的长度
		System.out.println("数组的长度"+a.length);
	}
	
}

案例：
public class Demo{
	public static void main(String[] args) {
	
		int[] a = {2,4,6,7,9};

		//取数据  访问每个元素
		System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		System.out.println(a[3]);
		System.out.println(a[4]);
		//获得数组的长度
		System.out.println("数组的长度"+a.length);
		
			
	}
	
}


遍历：就是将数组中的每个元素的值打印输出 依次访问
public class Demo{
	public static void main(String[] args) {
	
		int[] a = {2,4,6,7,9};

		//取数据  访问每个元素
		/*System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		System.out.println(a[3]);
		System.out.println(a[4]);*/
		//遍历
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]);
			
		}
		
		//获得数组的长度
		System.out.println("数组的长度"+a.length);
		
			
	}
	
}


练习：定义一个数组   数组中的元素是｛2,4,5,7,8,23,62,57｝ 找出数组中的奇数 并打印下标

public class Demo{
	public static void main(String[] args) {
		int[] a = {4,6,9,45,79,23,51,63};

		//遍历
		for(int i = 0;i<a.length;i++) {
			//对每个元素进行判断
			if (a[i]%2!=0) {
				System.out.print(i+",");
				
			} 
			
		} 
		
			
	}
	
}

提高题：
练习： 一个char数组 a b C D E G J j l a A s 将数组中的大写字母 转换成小写字母  最后打印输出转换后的结果
public class Demo{
	public static void main(String[] args) {
		char[] c = {'A','a','D','f','R','Z'};

		//遍历  挑出大写的字母  元素  65--90 之间 
		for(int i = 0;i<c.length;i++) {
			//判断每个元素是否在 65--90之间
			if(c[i]>=65&&c[i]<=90){
				c[i] = (char)(c[i]+32);
			}
		} 

		//遍历输出
		for(int i = 0;i<c.length;i++) {
			System.out.print(c[i]+",");
			
		} 
	}
	
}

数组元素的默认值

              默认值
整数类型
byte           0
short          0
int            0
long           0
小数类型
float          0.0
double         0.0
字符类型
char           '\u0000' 空字符
布尔类型 
boolean         false
                  
引用数据类型：     null
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		String[] a = new String[5];

		for(int i = 0;i<a.length;i++) {
			System.out.println(a[i]);
			
		} 

		
	}

	
}

数组的内存分析

结论：
每个元素的地址值 = 首地址+下标*数组数据类型字节数
这样的原理直接导致数组中的每个元素可以通过下标直接访问到 所以其查询的速度是非常快的

数组的扩容

1.创建一个新的大的数组
2.将旧数组数据 依次 复制到新数组中
3.将新数组的引用赋值给旧数组


第一种：自己做
代码：
public class Demo{
	public static void main(String[] args) {
		int[] a = {3,5,8,4,9,23};
		System.out.println("旧数组的长度："+a.length);

		//1.新建一个数组  长度是原来的2倍
		int[] b = new int[a.length*2];

		//2.将原数组的元素复制到新数组中
		for(int i = 0;i<a.length;i++) {
			//复制
			b[i] = a[i];
		}
		//3 将新数组的引用赋值给 a
		a = b;
		System.out.println("扩容之后的长度："+a.length);
		
		//4.遍历扩容之后的a数组
		for(int i = 0;i<a.length;i++) {
			System.out.print(a[i]+",");
			
		} 
		
		
	}
	
}


第二种： 利用java类库中的工具  System类 有一个函数  arraycopy()
System.arraycopy(原数组 ,原数组的起始下标 ,新数组 ,新数组的起始下标 ,要复制元素的长度 )
    
int[] a = {1,3,4,5}
int[] b = new int[8];{0,0,0,0,0,0,0,0}
System.arraycopy(a,0,b,1,3)
代码：
public class Demo{
	public static void main(String[] args) {
		int[] a = {3,5,8,4,9,23};
		System.out.println("旧数组的长度："+a.length);

		//1.新建一个数组  长度是原来的2倍
		int[] b = new int[a.length*2];

		//2.将原数组的元素复制到新数组中
		/*for(int i = 0;i<a.length;i++) {
			//复制
			b[i] = a[i];
		}*/
		System.arraycopy(a,0,b,0,a.length);
		//3 将新数组的引用赋值给 a
		a = b;
		System.out.println("扩容之后的长度："+a.length);
		
		//4.遍历扩容之后的a数组
		for(int i = 0;i<a.length;i++) {
			System.out.print(a[i]+",");	
		} 	
	}
}

第三种： 利用java类库中 Arrays中一个函数
copyOf(原数组,扩容之后的数组长度)  返回值类型是数组  
代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[] a = {3,5,8,4,9,23};
		System.out.println("旧数组的长度："+a.length);
		
		a = Arrays.copyOf(a,a.length*2);
		System.out.println("扩容之后的长度："+a.length);
		
		//4.遍历扩容之后的a数组
		for(int i = 0;i<a.length;i++) {
			System.out.print(a[i]+",");
			
		} 
		
		
	}
	
}


随机点名系统：
代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		String[] name = {"张三","李四","王五","赵四"};
		Scanner s = new Scanner(System.in);
		

		while (true) {
			System.out.println("请输入任意一个整数开始点名：");
			int a = s.nextInt();	
			int index = (int)(Math.random()*name.length);
			System.out.println(name[index]);
		}
	}
}

案例：  可以通过随机数 为一个数组中的元素赋值
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		//为数组的元素随机赋值
		int[] a = new int[10];

		//通过随机数进行赋值
		for(int i = 0;i<a.length;i++) {
			a[i] = (int)(Math.random()*1000);
		} 

		//遍历随机数组
		for(int i = 0;i<a.length;i++) {
			System.out.print(a[i]+",");
			
		} 
	}
	
}

数组用在函数的参数上

案例： 定义一个函数 传入一个数组 为这个数组遍历

参数：数组类型     int[] n
返回值类型： void

代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		//为数组的元素随机赋值
		int[] a = new int[10];

		//通过随机数进行赋值
		for(int i = 0;i<a.length;i++) {
			a[i] = (int)(Math.random()*1000);
		} 
		int[] b = {4,6,7,8,5,3,9};
		printArray(a);
		printArray(b);
	}
		
	public static void printArray(int[] n){
		//遍历随机数组
		for(int i = 0;i<n.length;i++) {
			System.out.print(n[i]+",");
			
		} 
		System.out.println();
	}
}

数组用在函数的返回值上

案例：可以将 数组扩容的代码 提取为一个函
myCopyOf()

参数： int[] n ,int lenth
返回值类型：int[]

代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		//为数组的元素随机赋值
		int[] a = new int[10];
		System.out.println("原数组的长度："+a.length);
		
		//通过随机数进行赋值
		for(int i = 0;i<a.length;i++) {
			a[i] = (int)(Math.random()*1000);
		} 

		//扩容
		a = myCopyOf(a,a.length*2);
		System.out.println("扩容之后的长度："+a.length);
		
		//遍历
		printArray(a);
	}
		
	public static void printArray(int[] n){
		//遍历随机数组
		for(int i = 0;i<n.length;i++) {
			System.out.print(n[i]+",");
			
		} 
		System.out.println();
		
	}

	public static int[] myCopyOf(int[] n,int length){
		//1创建一个新数组
		int[] b = new int[length];
		//2 复制元素
		for(int i = 0;i<n.length;i++) {
			b[i] = n[i];
		} 
		//3.将扩容之后的数组返回
		return b;
	}

	
}

函数的可变长参数

案例： 定义一个函数  功能是 计算多个int类型数据的和

//数组   将这些数据存放到int数组

语法： 定义在函数的形参列表中
数据类型...变量名
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		//
		int sum = add(1,3,4,5,6,7,8,9,8);
		System.out.println(sum);
		
	}

	public static int add(int...a){
		int sum = 0;
		for(int i = 0;i<a.length;i++) {
			sum+=a[i];
		} 

		return sum;
	}
}

注意事项：
1.函数的形参列表中只能定义一个可变长参数 
以下是错误的
public static int add(int...a,int...b){
		int sum = 0;
		for(int i = 0;i<a.length;i++) {
			sum+=a[i];
		} 

		return sum;
	}
2.一个函数的形参列表中可以定义多个参数 但是如果有可变长参数 那么可变长参数必须放在形参列表的最后
public static int add(int b,int...a){
		int sum = 0;
		for(int i = 0;i<a.length;i++) {
			sum+=a[i];
		} 

		return sum;
}
3.可变长参数就相当于一个数组 所以在调用函数的时候可以直接传入一个数组
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[] a = {1,3,4,5};
		int[] b = {2,5,8,9};
		int sum = add(a,b);
		System.out.println(sum);
		
	}

	public static int add(int[] b,int...a){
		/*int sum = 0;
		for(int i = 0;i<a.length;i++) {
			sum+=a[i];
		} */
		return 1;
	}
}

在数组中常见的一些异常

1.数组下标越界异常：
原因：访问数组元素的时候 下标超出了数组的最大下标（length-1）
案例：
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:at Demo.main(Demo.java:7)
案例：三生三世十里桃花
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[] a = {1,2,3,4,5};
		//下标 0--4

		System.out.println(a[5]);
	}

	
}

2.空指针异常
原因：当访问数组的时候  数组的引用值为null 
Exception in thread "main" java.lang.NullPointerException
        at Demo.main(Demo.java:7)
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[] a = {1,2,3,4,5};
		//下标 0--4
		a = null;
		System.out.println(a[0]);	
	}
}

数组的排序

｛1,4,8,2,6｝----->{1,2,4,6,8}

冒泡排序

规则： 相邻的两个元素进行比较 如果前者大于后者 那么两者交换位置
{3,8,1,2}----->{1,2,3,8}

***
**
*

代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[] a = {3,8,1,2};
		for(int i = 1;i<=a.length-1;i++) {//控制轮数
			for(int j = 0;j<=a.length-1-i;j++) {
				//比较 交换两个元素的值 a[j]---a[j+1]
				if (a[j]>a[j+1]) {
					int t = a[j];
					a[j] = a[j+1];
					a[j+1] = t;
				} 
				
			} 
		} 

		//遍历
		for(int i = 0;i<a.length;i++) {
			System.out.print(a[i]+",");
			
		} 
		
	}

	
}

选择排序

规则：选择一个数 依次和其他的数进行对比 如果这个数大于后者 那么两者交换位置
代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[] a = {3,8,1,24,7,5,8,34,56,78,21,32,12};
		//选择排序  int I = 0 i<a.length-1 i++      int j = i+1  j<=a.length-1 j++
		for(int i = 0;i<a.length-1;i++) {
			for(int j = i+1;j<=a.length-1;j++) {
				// a[i]--a[j]
				if (a[i]>a[j]) {
					int t = a[i];
					a[i] = a[j];
					a[j] = t;
				} 
				
			} 
		} 
		//遍历
		for(int i = 0;i<a.length;i++) {
			System.out.print(a[i]+",");
			
		} 
		
	}

	
}

快速排序

是java类库中提供的排序方法
Arrays类 中sort(传入需要排序的数组)
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[] a = {3,8,1,24,7,5,8,34,56,78,21,32,12};
		Arrays.sort(a);
		//遍历
		for(int i = 0;i<a.length;i++) {
			System.out.print(a[i]+",");
		} 
	}
}

二维数组

数组  
定义方式： 数据类型[]  数组名；
数组的类型：8中基本数据类型  String  数组类型 
数组类型的数组

int[][] = new int[][]
二维数组：在一个数组中的每一个元素都是一个数组

定义

数组的声明
	语法：
	数据类型[][] 数组名 ；
为数组开辟空间
	语法：
	数组名 = new 数据类型[高维数组的长度][低维数组的长度]

案例：
int[][] a = new int[4][3];

二维数组的访问

案例：遍历
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		//int[][] a = {{0,1,0},{0,0,2},{0,0,0},{0,0,0}};
			
		int[][] a = new int[4][3];
		//i  j
		a[0][1] = 1;
		a[1][2] = 2;

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

			for(int j = 0;j<a[i].length;j++) {
				System.out.print(a[i][j]+",");
				
			} 
			System.out.println();
			
		} 
		
	}

	
}

二维数组定义的方式

第一种：声明  分配空间
	1.先声明  再分配空间
	int[][] a;
	a = new int[3][4];
	2.声明的同时并分配空间
	int[][] a = new int[3][4];
第二种：声明 赋值
	1.先声明 后赋值
	int[][] a;
	a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
	2.声明的同时并赋值
	int[][] a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
	简写：
	int[][] a = {{1,2,3},{4,5,6},{7,8,9}};
	注意：简写方式声明和赋值必须在同一条语句
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[][] a;
		a = new int[3][4];

		int[][] b = new int[3][4];

		int[][] c;
		c = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

		int[][] d = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

		int[][] e = {{1,2,3},{4,5,6},{7,8,9}};
	}
}

不规则的二维数组

概念：高维数组的每个元素的数组长度是不一样的
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[][] a = {{1},{2,3},{4,5,6}};

		for(int i = 0;i<a.length;i++) {
			for(int j = 0;j<a[i].length;j++) {
				System.out.print(a[i][j]+",");
			}
			System.out.println();	 
		} 
	}
}

案例：在为二维数组初始化的时候可以先初始化高维数组 再初始化低维数组
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int[][] a = new int[3][];

		a[0] = new int[2];
		a[1] = new int[3];
		a[2] = new int[6];
		//
		for(int i = 0;i<a.length;i++) {
			for(int j = 0;j<a[i].length;j++) {
				System.out.print(a[i][j]+",");
				
			} 
			System.out.println();	
		} 	
	}	
}

注意：在定义二维数组的时候 不能先确定低维数组 因为低维数组的创建是依赖于高维数组的
int[][] a = new int[][4]; 这样写是错误的

勋大大

关注

0
点赞
踩
0

收藏

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

数组数组的概念概念：数组是内存中的一块连续的存储空间用于存放多个类型相同的数据是数据存储的一个容器变量只能存放一个值数组可以存放多个类型相同的值数组的定义1.数组的声明：确定了数组是用于存放什么类型的数据语法：数据类型[] 数组名；//建议数据类型 []数组名；数据类型数组名[]；//c语言的写法2.为数组开辟空间：确定了数组可以存放多...
复制链接

扫一扫

专栏目录