java09数组的使用

时间:2022-07-20 17:18:01
 
/**
* 求数组中的最大值
*/
@Test
public void test14(){
//定义一个数组 参赛的选手
int [] nums={50,20,30,80,100,90};
//定义一个擂主
int max=0;
//循环打擂
for (int i = 0; i < nums.length; i++) {
//如果发现 数组中的元素 大于 max 就让当前的元素的值给max
if (nums[i]>max) {
max=nums[i];
System.out.println("历届的擂主::"+max);
}
}
System.out.println("最终的擂主是:"+max);
}
/**
* 求数组中的最小值
*/
@Test
public void test15(){
//定义一个数组 参赛的选手
int [] nums={50,200,30,80,100,90};
//定义一个最小值 默认是 数组中的第一个元素
int min=nums[0];
//循环打擂
for (int i = 0; i < nums.length; i++) {
//如果发现数组中的元素小于min 把元素的值给min
if (nums[i]<min) {
min=nums[i];
}
}
System.out.println("最小的数值是:"+min);
}

求数组的最大和最小值

public class Array01 {

    /**
* 数组:一组相同数据类型的集合! 在内存中开辟一连串的空间!
* 和String一样都是 引用数据类型!
*
* 数据类型 [] 数组名称;
*
* 数组的下标=数组的长度-1
*/
public static void main(String[] args) {
// 01.声明数组 创建了一个火车厢
int[] nums;
// 02.分配空间 给火车厢创建座位
nums = new int[5];
// 03.赋值 旅客入座
nums[0] = 50;
// 04.使用 nums.length(获取数组的长度)
for (int i = 0; i < nums.length; i++) {
System.out.println("数组nums的第" + (i + 1) + "个位置的数据是:" + nums[i]);
}
} // 声明数组的同时给数组赋值
@Test
public void test01() {
/**
* 给你说 创建车厢的同时,告诉你里面有多少个座位
*
* int [] nums;
* nums={ 1, 2, 3, 4, 5 }; 这种写法是错误的!
*/
int[] nums = { 1, 2, 3, 4, 5 };
// 找到下标为3的数据
System.out.println(nums[3]);
} @Test
public void test02() {
// int[] nums = new int[5]; 可以 常用的方式
int[] nums = new int[] { 1, 2, 3, 4, 5 };
// 找到下标为3的数据
System.out.println(nums[3]);
} /**
* 计算5位学生的平均分
*/
@Test
public void test03() {
// 01.创建一个长度为5的double类型的数组 保存学生成绩
double[] scores = new double[5];
// 02.循环给学生成绩赋值
Scanner scanner = new Scanner(System.in);
double sum = 0; // 保存总成绩
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入第" + (i + 1) + "位同学的成绩");
scores[i] = scanner.nextDouble();
// 每个学生成绩需要加到sum中
sum += scores[i];
}
System.out.println("学生的总成绩是:" + sum);
System.out.println("学生的平均分是:" + (sum / scores.length));
} /**
* 有一个数列:8,4,2,1,23,344,12
循环输出数列的值
求数列中所有数值的和
猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数
*/
@Test
public void test04() {
// 01.创建int类型数组
int nums[] = { 8, 4, 2, 1, 23, 344, 12 };
// 定义变量保存总和
int sum = 0;
// 02.循环输出数列的值
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + ",");
sum += nums[i];
}
System.out.println("\n数组中数值的总和:" + sum);
// 猜数游戏:从键盘中任意输入一个数据,判断数列中是否包含此数
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个数字:");
int num = scanner.nextInt();
// 定义标记 来记录是否中奖
boolean flag = false;
for (int i = 0; i < nums.length; i++) {
if (num == nums[i]) {
flag = true;
break;
}
}
if (flag) { // 判断标记
System.out.println("恭喜您!中大奖!");
} else {
System.out.println("没有找到......");
}
} /**
* 以表格的形式输出5笔购物金额及总金额
*/
@Test
public void test05() {
double[] pays = new double[5];
double sum = 0; // 总金额
Scanner scanner = new Scanner(System.in);
System.out.println("请输入本月的消费记录:");
for (int i = 0; i < pays.length; i++) {
System.out.println("请输入" + (i + 1) + "次的消费金额:");
pays[i] = scanner.nextDouble(); // 给数组中每一个元素赋值
// 求和
sum += pays[i];
}
// 输出消费详情 遍历(从集合中取得数据)
System.out.println("序号\t\t金额");
for (int i = 0; i < pays.length; i++) {
System.out.println((i + 1) + "\t\t" + pays[i]);
}
System.out.println("总金额:" + sum);
} /**
* Arrays :数组的操作类
*/
@Test
public void test06() {
double[] pays = new double[5];
Scanner scanner = new Scanner(System.in);
System.out.println("请输入本月的消费记录:");
for (int i = 0; i < pays.length; i++) {
System.out.println("请输入" + (i + 1) + "次的消费金额:");
pays[i] = scanner.nextDouble(); // 给数组中每一个元素赋值
} // 没有排序的遍历
for (int i = 0; i < pays.length; i++) {
System.out.println(pays[i]);
}
System.out.println("*************升序之后***************");
Arrays.sort(pays);// 升序排列
for (int i = 0; i < pays.length; i++) {
System.out.println(pays[i]);
}
} }
/**
* 操作数组的工具类!
*
*/
public class Arrays02 { // equals(arr1, arr2) :比较两个数组的内容和长度 是否一致
@Test
public void testEquals() {
int[] nums1 = { 10, 20, 30, 50 };
int[] nums2 = nums1;
int[] nums3 = { 10, 20, 30 };
System.out.println("nums1与nums2比较:" + Arrays.equals(nums1, nums2));
System.out.println("nums1==nums2比较:" + (nums1 == nums2));
} // sort(arr):对数组中的元素进行升序的排列
@Test
public void testSort() {
int[] nums = { 10, 50, 30, 20 };
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
} /**
* toString :把一个数组变成字符串
* [10, 50, 30, 20] 集合toString的结果!
*/
@Test
public void testToString() {
int[] nums = { 10, 50, 30, 20 };
System.out.println(Arrays.toString(nums));
} /**
* fill(arr,val):将arr数组中的所有元素都赋值成了val
*/
@Test
public void testFill() {
int[] nums = { 10, 50, 30, 20 };
System.out.println(Arrays.toString(nums));
Arrays.fill(nums, 100);
System.out.println(Arrays.toString(nums));
} /**
* copyOf(arr,length):将数组arr复制成一个长度为length的新数组!
*/
@Test
public void testCopyOf() {
int[] nums = { 10, 50, 30, 20 };
int[] nums1 = Arrays.copyOf(nums, 3);
System.out.println(Arrays.toString(nums1));
} /**
* binarySearch(arr,val):查询val在arr数组中的下标!
* 必须先升序排列! Arrays.sort(arr)!!!!
*/
@Test
public void testBinarySearch() {
int[] nums = { 10, 50, 30, 20 };
Arrays.sort(nums); // 10 20 30 50
System.out.println(Arrays.binarySearch(nums, 50));
} }
// 打擂法 求数组中的最大值
@Test
public void test01() {
int[] nums = { 10, 50, 30, 200 };
// 默认的擂主
int max = nums[0];
// 让max依次和nums中的每一个元素进行比较
for (int i = 0; i < nums.length; i++) {
if (max < nums[i]) {
max = nums[i];
}
}
System.out.println("最大值:" + max);
} /**
* 插入算法
*/
@Test
public void test02() {
// 先定义一个有序的数组
int[] nums = new int[5];
nums[0] = 100;
nums[1] = 90;
nums[2] = 80;
nums[3] = 10;
Scanner scanner = new Scanner(System.in);
System.out.println("请您输入一个插入的数据:");
int num = scanner.nextInt();
// 01.找到需要插入数据的位置
int index = nums.length;
// 02.循环找到位置
for (int i = 0; i < nums.length; i++) {
if (num > nums[i]) {
index = i; // 下标
break;
}
}
// 03.元素后移
for (int j = nums.length - 1; j > index; j--) {
nums[j] = nums[j - 1]; // 依次后移
}
// 04.插入数据
nums[index] = num;
System.out.println("插入数据的下表是:" + index);
System.out.println(Arrays.toString(nums)); }
public class CharSort03 {

    /**
* 字符的逆序输出
*/
public static void main(String[] args) {
char[] chars = { 'a', 'f', 'c', 'g', 'z', 'y' };
// 升序
Arrays.sort(chars);
System.out.println("升序之后的字符===》" + Arrays.toString(chars));
// 逆序
System.out.println("逆序之后的字符====");
for (int i = chars.length - 1; i >= 0; i--) {
System.out.print(chars[i]);
}
} @Test
public void test01() {
// char类型的默认值: '\u0000'
char[] chars = { 'a', 'c', 'f', 'g', 'y', 'z', '\u0000' }; // 必须有顺序 System.out.println(chars.length);
char c = 'x'; // 需要插入的字符
int index = chars.length;
// 找下标
for (int i = 0; i < chars.length; i++) {
if (c < chars[i]) {
index = i;
break;
}
}
// 元素后移
for (int j = chars.length - 1; j > index; j--) {
chars[j] = chars[j - 1];
}
// 插入数据
chars[index] = c;
for (int i = 0; i < chars.length; i++) {
System.out.print(chars[i]);
}
}
}
public class DoubleArray04 {

    public static void main(String[] args) {

        int[] clazz = new int[3]; // 保存班级
int[] students = new int[5]; // 保存学生 } @Test
public void test01() { // 声明的同时开辟空间
int[][] nums = new int[3][5]; // 3个班级各5名学生
} @Test
public void test02() { // 先声明 再 开辟空间
int[][] nums;
nums = new int[3][5]; // 3个班级各5名学生
} @Test
public void test03() { // 声明 开辟空间的同时赋值
int[][] nums = { { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 },
{ 1, 2, 3, 4, 5 } };
System.out.println(nums.length);// 3个班级各5名学生
} @Test
public void test04() {
int[][] nums = new int[3][5]; // 3个班级各5名学生
// 第二个班级的第三个学生
nums[1][2] = 50;
} @Test
public void test05() {
int[][] nums = { { 1, 2, 3 }, { 10, 20, 30 }, { 100, 200, 300 } }; /**
* nums.length 车厢数
* nums[i].length 车厢中的座位数
* 双重循环:
* 外层循环执行一次,内存循环执行一遍!
*/
for (int i = 0; i < nums.length; i++) {
System.out.println("进入了第" + (i + 1) + "个车厢**********");
if (i == 2) {
break; // 跳出当前循环体
}
for (int j = 0; j < nums[i].length; j++) {
if (j == 2) {
break; // 跳出当前循环体
}
System.out.println(nums[i][j]);
}
}
} /**
* 所有的引用数据类型如果没有实例化(开辟空间)! 不能使用!
* 因为引用数据类型的默认值 是 null!
*/
@Test
public void test06() { int[][] nums = new int[5][];
System.out.println(nums.length);
nums[0] = new int[5]; // 开辟空间
nums[1] = new int[6]; nums[0][0] = 50; // 使用
nums[0][1] = 60;
nums[0][2] = 70;
nums[0][3] = 80;
System.out.println(nums[0].length);
System.out.println(nums[1].length);
} }
    /**
* 冒泡排序 升序的排列
*/
@Test
public void test17(){
int [] nums={1,5,8,2,3,5};
/**
* 外层循环控制轮数 数组的长度-1
* 外层循环每执行一次, 内层循环执行一遍
*/
for (int i = 0; i < nums.length-1; i++) {
System.out.println("这是第"+(i+1)+"轮===================");
//内层循环 数组的长度-1-i
for (int j = 0; j < nums.length-i-1; j++) {
System.out.println("比较了第"+(j+1)+"次");
}
}
} /**
* 冒泡排序 升序的排列
*/
@Test
public void test18(){
int [] nums={10,5,8,2,3,50,5000,500,30,65,98};
/**
* 外层循环控制轮数 数组的长度-1
* 外层循环每执行一次, 内层循环执行一遍
*
* 无论多少个数字相比
* 都是相邻的两个数字进行比较,
* 数值小的元素会交换前面的位置
* 代码:
* 外层循环 : 数组长度-1
* 内层循环: 数组长度-1-i
*
*/
for (int i = 0; i < nums.length-1; i++) {
//内层循环 数组的长度-1-i
for (int j = 0; j < nums.length-i-1; j++) {
if (nums[j]>nums[j+1]) { //相当于 第一个元素大于下一个元素 ,那么需要和下个元素换位置
//等量转换
int temp=nums[j];
nums[j]=nums[j+1];
nums[j+1]=temp;
}
}
}
//遍历数组中的元素
for (int i : nums) {
System.out.println(i);
}
}

冒泡排序

public class TestArrays {

    /**
* Arrays.equals(数组1,数组2)
* 01.首先比较的而是数组的长度是否一致
* 02.比较数组中的元素
*/
@Test
public void test01(){
int nums1[]={10,20,30};
int nums2[]={10,20,30};
int nums3[]={10,30,20};
System.out.println(nums1==nums2); //比较内存地址 false
//equals
System.out.println(nums1.equals(nums2)); //底层还是比较内存地址 false
System.out.println(Arrays.equals(nums1, nums2)); //true
//System.out.println(Arrays.equals(nums1, nums3)); //false
} /**
* [L@4a7fca02 :数组toString()的结果
*/
@Test
public void test02(){
int nums1[]={10,20,30};
System.out.println(nums1);
//把数组转换成字符串
System.out.println(Arrays.toString(nums1));
} @Test
public void test03(){
int nums1[]={10,20,30};
//把数组转换成字符串
System.out.println(Arrays.toString(nums1));
//copyOf(数组,长度)
int[] nums2 = Arrays.copyOf(nums1, 10);
System.out.println(Arrays.toString(nums2));
} @Test
public void test04(){
int nums1[]={10,20,30};
System.out.println("nums1之前的值:"+Arrays.toString(nums1));
//fill(数组,值)
Arrays.fill(nums1, 500);
System.out.println("nums1fill之后的值:"+Arrays.toString(nums1));
} /**
* binarySearch(数组,值)
* 查询值 在数组中下标的位置
*/
@Test
public void test05(){
int nums1[]={100,200,10,20,30};
//01.必须先排序 升序
Arrays.sort(nums1);
//02.查询20的下标 [10,20,30,100,200]
System.out.println(Arrays.binarySearch(nums1, 300));
} }

Arrays工具类的使用

/**
*
* 二维数组: 数组中的元素 又是一个数组!
*/
@Test
public void test06(){
//01.创建二维数组
int[][] nums=new int[3][3]; //int [][] nums2={{1,2,3},{4,5,6},{7,8,9}}; nums[0][0]=5;
nums[0][1]=6;
nums[0][2]=7; nums[1][0]=5;
nums[1][1]=6;
nums[1][2]=7; nums[2][0]=5;
nums[2][1]=6;
nums[2][2]=7; } @Test
public void test07(){
//01.创建二维数组
int [][] nums={{1,2,3,4},{4,5,6},{7,8}}; System.out.println(nums[0]);//{1,2,3}
System.out.println(nums[0][1]);//
System.out.println("nums的长度:"+nums.length);
System.out.println("第2个数组中下标是2的元素"+nums[1][2]);
} /**
* 循环打印出数组所有的元素
*/
@Test
public void test08(){
//01.创建二维数组
int [][] nums={{1,2,3,4},{4,5,6},{7,8}};
for (int i = 0; i < nums.length; i++) { //外层
System.out.println("这是2维数组中的第"+(i+1)+"个数组");
for (int j = 0; j < nums[i].length; j++) {//内层
System.out.println("元素的值:"+nums[i][j]);
}
} }

二维数组

    /**
*
* 已知有3个班级各3名学员,请使用
*二维数组计算各个班级的总成绩
*/ @Test
public void test10(){
//01.创建二维数组
int [][] nums=new int[3][3];
Scanner scanner=new Scanner(System.in);
//定义一个数组变量 存储每个班级的成绩
int sum[]=new int[nums.length];
//02.让用户循环给数组 赋值
for (int i = 0; i < nums.length; i++) {
System.out.println("请输入第"+(i+1)+"个班级的学生成绩:");
for (int j = 0; j < nums[i].length; j++) {
System.out.println("请输入第"+(j+1)+"个成绩:");
nums[i][j]=scanner.nextInt(); //学生成绩赋值
sum[i]+=nums[i][j]; //每个班级的总成绩
}
}
System.out.println("学生的成绩***********************"); for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
System.out.println("第"+(i+1)+"个班级的第"+(j+1)+"个学生的成绩:"+nums[i][j]);
}
}
System.out.println("班级的成绩***********************");
for (int i = 0; i < sum.length; i++) {
System.out.println("第"+(i+1)+"个班级的总成绩是:"+sum[i]);
}
} @Test
public void test011() {
//有3个班各3名学生某门课程的成绩,
//01.定义一个2维数组
int [][] scores=new int[3][3];
Scanner scanner=new Scanner(System.in);
//02.循环给学生赋值
for (int i = 0; i < scores.length; i++) {
System.out.println("请输入第"+(i+1)+"班级学生的成绩:===========");
for (int j = 0; j < scores[i].length; j++) {
System.out.println("请输入第"+(j+1)+"个学生的成绩:");
scores[i][j]=scanner.nextInt();
}
}
System.out.println("学生的成绩统计如下******************");
// 如何计算3个班各自的总成绩? for (int i = 0; i < scores.length; i++) {
// 每个班级都清零
int sum = 0;
for (int j = 0; j < scores[i].length; j++) {
sum += scores[i][j];
}
System.out.println("第" + (i + 1) + "班级学生的成绩总和===" + sum);
} }

二维数组小练习