9.26-数组

概念

同一类型数据的集合。其实数组就是一个容器。

好处

可以自动给的数组中的元素从0开编号(下标),
方便操作这些元素

定义数组的两种格式

格式一:(直接指定数组的长度(元素数量))

元素类型[] 数组名 = new 元素类型[数组的长度];
//通过new关键字创建一个int类型的数组对象,这个容器中有3个元素
int[] ary = new int[3];

注意

元素类型[] 数组类型 int[] double[] String[]

格式二（指定数组元素）

元素类型[] 数组名 = new 元素类型[]{元素1,元素2,...};
int[] ary = new int[]{3,5,1,7};

简写:

//静态初始化,只能用于声明数组变量的同时进行初始化
int[] ary = {3,5,1,7};

元素类型 [] 数组名 = new 元素类型[]{元素1,元素2,元素3...};
int [] arr =new int []{1,2,3,4};

//简写：静态初始化,只能用于声明变量的同时进行初始化
int [] arr ={1,4,4,56}

例子

package day9_26;

import java.util.Arrays;

public class ArryDemo02 {
	/**
	 * 格式二演示
	 */
	public static void main(String[] args) {
		int [] arr = {1,2,3};
		//输出数组内容
		System.out.println(Arrays.toString(arr));
		//输出arr数组长度
		System.out.println(arr.length);
		//获取arr数组下标为0的元素
		System.out.println(arr[0]);
		//将arr数组的第一个元素改为8
		arr[0]=8;
		System.out.println(Arrays.toString(arr));
		/*
		 *数组下标越界 异常
		 *	int i = arr[arr.length];
		 *	System.out.println(i);
		 */
		/*		
		arr =null;
		空指针异常
		用null调用任何的属性和方法都会引发空指针异常
		System.out.println(arr.length);
		*/
		
		}		
	}

数组的填充与迭代（遍历）

例子一

package day9_26;

import java.util.Arrays;

public class ArrayDemo03 {
	public static void main(String[] args) {
		//数组的填充
		int []ary =new int[10];
		System.out.println(Arrays.toString(ary));
		for(int i=0;i<ary.length;i++) {
			/*
			 * Math 系统类（数学类）
			 *random() 生成一个随机的小数[0.0,1.0)
			 */
			ary [i]=(int) (Math.random()*10);
		}
		System.out.println(Arrays.toString(ary));
		//数组的遍历（迭代）
		String [] names = {"jack","rose","tom","jerry","andy"};
		for(int i=0;i<names.length-1;i++) {
			String name = names [i];
			System.out.println(name);
		}
	}
}

例子二-回文数

package day9_26;

import java.util.Scanner;

public class ArrayDemo04 {
	/**
	 * 需求:
	 * 在控制台输入一个五位的正整数
	 * 判断该整数是否为回文数
	 * 12321 回文数
	 * 34943 回文数
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner sc =new Scanner(System.in);
		System.out.println("请输入一个五位正整数：");
		//五位数判断
		int num;
		while(true) {
			num =sc.nextInt();
			if(num<10000||num>99999) {
				System.out.println("格式错误，请重新输入:");
			}else {
				break;
			}
		}
		/*
		 * String valueOf(int n)
		 * 将给定的整数转换为字符串
		 */
		String str = String.valueOf(num);
		/*
		 * String toCharArray()
		 * 将当前字符串转换为对应的字符数组char[]
		 * "12345"-》['1','2','3','4','5']
		 */
		char [] chs =str.toCharArray(); 
		if(chs[0]==chs[4]&&chs[1]==chs[3]) {
			System.out.println(num+"是回文数");
		}else {
			System.out.println(num+"不是回文数");
		}
	}
}

Arrays 数组工具类

Arrays.toString()

将给定数组中的元素链接为字符串，目的是便于输出

package day9_26;

import java.util.Arrays;

public class ArrarysDemo01 {
	public static void main(String[] args) {
		int [] ary= {1,23,5,4,31,22};
		System.out.println(ary);//打印内存地址
		System.out.println(Arrays.toString(ary));
		String [] names= {"jack","rose","tom"};
		System.out.println(names);
		System.out.println(Arrays.toString(names));
		char [] input = {'a','b','c'};
		//字符数组较为特殊，可以直接作为字符串输出
		System.out.println(input);
		}
}

Arrays.equals()

比较两个数组的内容是否相等（包括内容、长度、大小、位置等）

package day9_26;

import java.util.Arrays;

public class ArraysDemo02 {
	public static void main(String[] args) {
		int [] ary1 = {2,3,4};
		int [] ary2 = {2,3,4};
		//"=="比较的是是否为同一对象
		System.out.println(ary1==ary2);
		//比较两个数组的内容是否相等
		System.out.println(Arrays.equals(ary1,ary2));
	}
}

Arrays.sort()

数组的排序方法（升序）

public class ArraysDemo03 {
	public static void main(String[] args) {
		int [] ary =  {3,6,1,31,34};
		System.out.println("排序前"+Arrays.toString(ary));
		Arrays.sort(ary);
		System.out.println("排序后"+Arrays.toString(ary));
		String [] names= {"rose","jack","tom","andy"};
		System.out.println("排序前"+Arrays.toString(names));
		Arrays.sort(names);
		//根据字符串首字母Unicode整数编码进行排序
		System.out.println("排序后"+Arrays.toString(names));
	}
}

Arrays.binarySearch()

二分查找法：根据给定的元素查找对应的下标

注意：不能在未排序的数组上进行查找

package day9_26;

import java.util.Arrays;

public class ArraysDemo04 {
	public static void main(String[] args) {
		String [] names= {"rose","jack","tom","andy"};
		System.out.println("排序前"+Arrays.toString(names));
		Arrays.sort(names);
		//根据字符串首字母Unicode整数编码进行排序
		System.out.println("排序后"+Arrays.toString(names));
		//要查找的数组、要查找的元素
		int index = Arrays.binarySearch(names, "jack");
		System.out.println(index);
	}
}

Arrays.copyOf()

数组的复制加扩充方法（复制为新数组）

package day9_26;

import java.util.Arrays;

public class ArraysDemo05 {
	public static void main(String[] args) {
		int [] ary1 = {2,3,4};
		/*
		 * original 原数组
		 * newLength 复制后的新数组长度
		 */
		int [] ary2 = Arrays.copyOf(ary1,ary1.length);
		System.out.println(Arrays.toString(ary2));
		System.out.println(ary1==ary2);//false
		String [] films = {
				"隐入尘烟",
				"明日战记",
				"独行月球"
		};
		films = Arrays.copyOf(films, films.length+1);
		System.out.println(Arrays.toString(films));
		films[films.length-1]="笔仙大战贞子";
		System.out.println(Arrays.toString(films));
	}
}

Arrays.fill(）

数组的填充

package day9_26;

import java.util.Arrays;

public class ArraysDemo06 {
	public static void main(String[] args) {
		int [] ary =new int [10];
		//要填充的数组、要填充的值
		Arrays.fill(ary, 8);
        //只能将所有元素填充为此值，不能填充不同值
		System.out.println(Arrays.toString(ary));
	}
}

System.arraycopy()

数组的复制（可以在两个已经存在的数组之间进行复制）

package day9_26;

import java.util.Arrays;

public class SystemDemo {
	public static void main(String[] args) {
		int [] line1 = {0,0,0,0,5,6,7,8};
		int [] line2 = {1,2,3,4,0,0,0,0};
		int [] line3 = {0,0,3,4,0,0,7,8};
		/*
		 * src 待复制的数组
		 * scrPos 待复制数组的起始位置(下标值)
		 * dest 复制到的数组
		 * destPos 复制到数组的起始位置(下标值)
		 * length 复制的长度
		 */
	System.arraycopy(line2, 0, line1, 0, 4);
	System.out.println(Arrays.toString(line1));
	System.arraycopy(line2, 0, line3, 0, 2);
	System.out.println(Arrays.toString(line3));
	System.arraycopy(line1, 4, line3,4, 2);
	System.out.println(Arrays.toString(line3));
	}
}

练习题

练习题一-双色球

 * 需求：
 * 双色球随机选号
 * 规则：
 * 1.六个红球 01~33 里面随机取出6个，不可重复，且按升序排序
 * 2.一个蓝球 01~16里随机取出一个
 * 3.将结果输出为一个数组

package day9_26;

import java.util.Arrays;
import java.util.Random;

public class DoubleColorBall_v1 {
	/*
	 * 双色球随机选号规则
	 * 1.六个红球 01~33 里面随机取出6个，不可重复，且按升序排序
	 * 2.一个蓝球 01~16里随机取出一个
	 * 
	 */
	public static void main(String[] args) {
		//红球池
		String [] redPool = {"01","02","03","04","05","06","07","08","09","10",
				"11","12","13","14","15","16","17","18","19","20",
				"21","22","23","24","25","26","27","28","29","30","31","32"};
		//取出号码暂存池
		String [] poolEnd = new String[6];
		//随机生成并赋值暂存池
		Random rd = new Random();
		for(int i=0;i<poolEnd.length;i++) {
			int Rnum=rd.nextInt(redPool.length);
			poolEnd[i]=redPool[Rnum];
			//用红球池的末尾元素覆盖掉随机出的元素
			redPool[Rnum]=redPool[redPool.length-1];
			//利用缩容将红球池最后一个元素删除
			redPool=Arrays.copyOf(redPool, redPool.length-1);
		}
		//创建篮球池
		String [] bluePool = {"01","02","03","04","05","06","07","08","09","10",
				"11","12","13","14","15","16"};
		String bluePoolEnd = bluePool[rd.nextInt(16)];
		//扩容暂存池
		poolEnd  =Arrays.copyOf(poolEnd,poolEnd.length+1);
		poolEnd[poolEnd.length-1]=bluePoolEnd;
		//排序
		Arrays.sort(poolEnd);
		System.out.println(Arrays.toString(poolEnd));
	}
}

练习题二-双色球增强写法

 *基础规则与上题相同
 *额外需求：
 *将随机生成双色球的代码封装为方法，且判断方法的循环不允许使用与上题相同的方式
 *方法返回字符串
 *排除重复使用贴标签方式，新建等长boolean数组，亿boolean数组状态来判断是否重复
 *控制台输入要购买的注数，打印对应数量的双色球号码

package day9_26;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class DoubleColorBall_v2 {
	/**
	 *将随机生成双色球的代码封装为方法
	 *方法返回字符串
	 *排除重复，使用贴标签方式，新建等长boolean数组
	 *控制台输入要购买的注数，打印对应数量的双色球号码
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入购买注数");
		int num = sc.nextInt();
		for(int i =1;i<=num;i++) {
			System.out.println(Arrays.toString(gen()));
		}
	}
	public static String [] gen() {
		//红球池
		String [] redPool = {"01","02","03","04","05","06","07","08","09","10",
				"11","12","13","14","15","16","17","18","19","20",
				"21","22","23","24","25","26","27","28","29","30","31","32"};
		//取出号码暂存池
		String [] poolEnd = new String[6];
		//创建随机生成对象
		Random rd = new Random();
		//创建标签池
		boolean [] redPoolTag = new boolean[redPool.length];
		//填充标签默认值为false
		//Arrays.fill(redPoolTag, false);
		//循环
		int i=0;
		while(true) {
			//生成随机下标
			int Rnum=rd.nextInt(redPool.length);
			//判断下标是否被使用
			if(redPoolTag[Rnum]) {
				continue;
			}
			//将随机值赋值到暂存池
			poolEnd[i]=redPool[Rnum];
			//将下标状态修改为已使用
			redPoolTag[Rnum]=true;
			//循环结束自增
			i++;
			//结束循环
			if(i==poolEnd.length) {
				break;
			}
		}
		//创建蓝球池
		String [] bluePool = {"01","02","03","04","05","06","07","08","09","10",
				"11","12","13","14","15","16"};
		String bluePoolEnd = bluePool[rd.nextInt(16)];
		//扩容暂存池
		poolEnd  =Arrays.copyOf(poolEnd,poolEnd.length+1);
		poolEnd[poolEnd.length-1]=bluePoolEnd;
		//排序
		Arrays.sort(poolEnd);
		return poolEnd;
		
		
	}
}

上一页9.23-嵌套循环与方法下一页9.27-排序与递归调用

最后更新于2年前