Java基础day07 - 一维数组及排序方式与二维数组

已于 2024-03-28 14:47:24 修改
阅读量223 收藏
点赞数 3
文章标签： java 开发语言
于 2024-03-27 18:48:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liang79096/article/details/137085366
版权

1、习题

（1）数组中元素的筛选

注意：这两个筛选题中都用了标记的方法

import java.util.Scanner;

/*
3、已知本组学员有：
	String[] names = {"张三","李四","王五","赵六","钱七"};
	从键盘输入一个学生姓名，
	查看他是否是本组学员
	说明：
		字符串比较：boolean boo = "张三".equals("李四");
 */
public class Demo1 {
    public static void main(String[] args) {
        //1.创建数组并初始化 - 静态初始化
        String[] names = {"张三","李四","王五","赵六","钱七"};
        //2.从键盘读取数据
        Scanner s = new Scanner(System.in);
        System.out.print("请输入你要查找的姓名:");
        String name = s.next();
        //3.判断是否是本组学员
        boolean isFlag = false;//默认不是本组成员
        for(int i = 0; i <= names.length - 1; i++){//在这i当作索引使用
            String n = names[i];
            if (n.equals(name)){//n.equals(name) :比较字符串的内容。如果相同返回true否则返回false
                isFlag = true;
                break;
            }
        }

        if (isFlag) {
            System.out.println(name + "是本组的成员");
        }else{
            System.out.println(name + "不是本组成员");
        }
    }
}

import java.util.Scanner;

/*
3、已知本组学员有：
	String[] names = {"张三","李四","王五","赵六","钱七"};
	从键盘输入一个学生姓名，
	查看他是否是本组学员
	说明：
		字符串比较：boolean boo = "张三".equals("李四");
 */
public class Demo1 {
    public static void main(String[] args) {
        //1.创建数组并初始化 - 静态初始化
        String[] names = {"张三","李四","王五","赵六","钱七"};
        //2.从键盘读取数据
        Scanner s = new Scanner(System.in);
        System.out.print("请输入你要查找的姓名:");
        String name = s.next();
        //3.判断是否是本组学员
        boolean isFlag = false;//默认不是本组成员
        for(int i = 0; i <= names.length - 1; i++){//在这i当作索引使用
            String n = names[i];
            if (n.equals(name)){//n.equals(name) :比较字符串的内容。如果相同返回true否则返回false
                isFlag = true;
                break;
            }
        }

        if (isFlag) {
            System.out.println(name + "是本组的成员");
        }else{
            System.out.println(name + "不是本组成员");
        }
    }
}

（2）遍历

注意：使用Arrays.toString 可以直接遍历输出数组中的内容（勤加练习）

/*
1.随机产生5个[0,100)的偶数放到数组中 ，并遍历输出
 */
public class ArrayExer1 {
    public static void main(String[] args) {

        //创建数组
        int[] numbers = new int[5];

        //生成随机数
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = (int)(Math.random() * 50) * 2;
        }

        /*
            调用方法：
                对象名.方法名
                类名.方法名
         */
        //将数组中的元素拼接成字符串
        String s = Arrays.toString(numbers);

        /*
        String s = "";//空串
        //遍历数组
        for (int i = 0; i < numbers.length; i++) {
            s += numbers[i] + ",";
        }
        */

        System.out.println(s);
    }
}
/*
2.
（1）用一个数组，保存星期一到星期天的7个英语单词，数组如下：
    {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"}
（2）从键盘输入1-7的整数，显示该整数对应的单词
 */
public class ArrayExer2 {
    public static void main(String[] args) {
        String[] week = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};

        Scanner s = new Scanner(System.in);
        System.out.print("请输入1-7的整数");
        int number = s.nextInt();

        System.out.println(week[number - 1]);//number在这是索引值
    }
}

/*
（1）用一个数组存储26个英文字母的小写形式a-z
（2）遍历显示小写字母以及它对应的大写字母，例如：a->A，b->B，c->C等
（3）提示：小写字母'a'对应编码值是97，字母'b'对应编码值是98，依次类推
     大写字母'A'对应编码值是65，字母'B'对应编码值是66，依次类推
 */
public class ArrayExer3 {
    public static void main(String[] args) {
        //创建一个数组存放英文字母
        char[] cs = new char[26];

        //给数组赋值
        //方式一
//        for (int i = 0; i < cs.length; i++) {
//            cs[i] = (char)(97 + i);
//        }

        //方式二
        char c = 'a';
        for (int i = 0; i < cs.length; i++) {
            cs[i] = c++; // ++不会改变原来的类型
        }


        //遍历数组同时将小写转成大写
        for (int i = 0; i < cs.length; i++) {
            System.out.println(cs[i] + "====" + (char)(cs[i]-32));
        }
    }
}

/*
4.用一个数组存储本组学员的姓名，先从键盘输入小组人数，再从键盘输入每一个学员的姓名，
    然后遍历显示。


    快捷键 : shift + 回车 - 向下另起一行
 */
public class ArrayExer4 {
    public static void main(String[] args) {
        //数组的声明
        String[] names;

        Scanner s = new Scanner(System.in);
        System.out.print("请输入学员的人数:");
        int number = s.nextInt();

        //数组进行初始化
        names = new String[number];

        //循环-给数组赋值
        for (int i = 0; i < names.length; i++) {
            System.out.print("请输入学生的姓名:");
            //将键盘输入的数据赋值给数组
            names[i] = s.next();
        }

        System.out.println(Arrays.toString(names));

    }
}

2.数组的顺序排列

查找数组中的最大值

/*
    查找数组中的最大值
 */
public class ArrayMaxNumberTest {
    public static void main(String[] args) {
        int[] numbers = {10,5,9,20,3};

        //最大值 - 默认把数组中的第一个元素当成最大值
        int maxNumber = numbers[0];
        int maxIndex = 0;
        
        //比较
        for (int i = 1; i < numbers.length; i++) {//遍历数组 不包括第一个
            if (maxNumber < numbers[i]){//说明maxNumber中的值不是最大的
                //将maxNumber中的值换掉
                maxNumber = numbers[i];
                maxIndex = i;
            }
        }

        System.out.println("index=" + maxIndex + " maxNumber=" + maxNumber);

    }
}

找数组中的最大值

/*
    找数组中元素的最大值（记录的是索引值）
 */
public class ArrayMaxNumberTest2 {
    public static void main(String[] args) {
        int[] numbers = {10,5,9,20,3};
        
        int maxIndex = 0;//最大元素的索引位置

        for (int i = 1; i < numbers.length; i++) {
            //比较
            if (numbers[i] > numbers[maxIndex]){//说明maxIndex记录的位置的元素不是最大的
                //修改maxIndex的索引值
                maxIndex = i;
            }
        }

        System.out.println("maxIndex:" + maxIndex);
    }
}

数组的元素进行翻转

/*
    对数组中的元素进行翻转
 */
public class ArrayReverseTest {
    public static void main(String[] args) {
        int[] numbers = {5,6,9,11,20,23};
        //方式一：
        /*
        for (int i = 0; i < numbers.length / 2; i++) {
            int temp = numbers[i];
            numbers[i] = numbers[numbers.length - 1 -i];
            numbers[numbers.length - 1 -i] = temp;
        }
         */

        //方式二
        for (int i = 0,j = numbers.length -1; i < numbers.length / 2; i++,j--) {
            int temp = numbers[i];
            numbers[i] = numbers[j];
            numbers[j] = temp;
        }

        System.out.println(Arrays.toString(numbers));
    }
}

冒泡排序

掌握      逐个比较取最大值     

53642
35642
35642
35462
35426
35426
34526
34256
34256
32456
23456
public class BubbleSortTest {
    public static void main(String[] args) {
        int[] numbers = {5,3,6,4,2};

        for (int i = 0; i < numbers.length - 1; i++) { //控制轮

            for (int j = 0; j < numbers.length - 1 - i; j++) {//控制交换次数

                //比较当前值和下一个值的大小
                if (numbers[j] > numbers[j + 1]){
                    //数据交换
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }

            }
        }

        System.out.println(Arrays.toString(numbers));

    }
}

线性查找某个元素

无序

/*
    从数组中查找某个元素 - 线性查找
 */
public class FindNumberTest {
    public static void main(String[] args) {
        //1.数组中的数据是无序的
        int[] numbers = {5,2,3,1,9};
        //要查找的数据
        int findNumber = 19;
        //记录元素所在的位置（索引位置）
        int index = -1;
        //遍历数组
        for (int i = 0; i < numbers.length; i++) {
            if (findNumber == numbers[i]){
                index = i;//将当前的索引值赋值给index
                break;
            }
        }

        if (index != -1) {
            System.out.println("要查找的数据在数组的" + index + "索引位置");
        }else{
            System.out.println("没有找到该数据");
        }



    }
}

有序

/*
    从数组中查找某个元素 - 线性查找
 */
public class FindNumberTest2 {
    public static void main(String[] args) {
        //1.数组中的数据是有序的
        int[] numbers = {2,3,5,6,9};
        //要查找的数据
        int findNumber = 4;
        //记录元素所在的位置（索引位置）
        int index = -1;
        //遍历数组
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("===");
            if (findNumber == numbers[i]){
                index = i;//将当前的索引值赋值给index
                break;
            }else if(numbers[i] > findNumber){//判断当前元素的值是否大于要找的值。如果大于说明要找的值已经不存在了
                break;
            }
        }

        if (index != -1) {
            System.out.println("要查找的数据在数组的" + index + "索引位置");
        }else{
            System.out.println("没有找到该数据");
        }



    }
}

选择排序

/*
    直接选择排序（选择排序）
 */
public class SelectionSortTest {
    public static void main(String[] args) {

        int[] numbers = {3,9,2,6,1};

        //控制轮
        for (int i = 0; i < numbers.length - 1; i++) {

            //最小值所在的索引位置
            int minIndex = i;

            //比较（比较元素的索引的范围）
            //j = i + 1 : 因为每i轮的第i个索引位置的元素当成最小值 所以要比较的范围就要从i+1开始到最后
            for (int j = i + 1; j < numbers.length; j++) {
                //比较两个数的大小
                if (numbers[minIndex] > numbers[j]){//说明当前记录的最小值不是最小的
                    //重新修改最小值的索引值
                    minIndex = j;
                }
            }

            if (minIndex != i) {
                //交换-将该轮找到的最小值和第i个位置进行位置交换--- 我们排序是从小到大
                int temp = numbers[minIndex];
                numbers[minIndex] = numbers[i];
                numbers[i] = temp;
            }
        }


        System.out.println(Arrays.toString(numbers));

    }
}

3.二维数组

/*
    二维数组：可以理解一维数组中的元素还是一维数组
 */
public class ArrayTest {
    public static void main(String[] args) {
        //二维数组的声明
        int[][] numbers;
        int numbers2[][];
        int[] numbers3[];

        //初始化
        //静态初始化
        //方式一 数组的声明和初始化可以分开
        numbers = new int[][]{{1,2},{2,2},{3,1}};//二维数组的长度3  二维数组的元素的长度是2
        //方式二：注意 数组的声明和初始化不能分开写。
        String[][] persons = {{"龙哥","男"},{"伟哥","女","110"},{"杰哥","x"}};

        //获取元素的值
        String name = persons[1][0]; //1指的是二维数组的索引值  0指的是二维数组元素的索引值。
        System.out.println(name);
        //给元素赋值
        persons[1][1] = "男";
        System.out.println(persons[1][1]);

        //数组的长度
        //二维数组的长度
        System.out.println(persons.length);
        //二维数组的元素的长度
        System.out.println(persons[1].length);


        //遍历二维数组
        String[][] persons2 = {{"a","男"},{"伟哥","女","110"},{"c","x"}};
        //先遍历二维数组 -- 二维数组的元素是一维数组
        for (int i = 0; i < persons2.length; i++) {
            //获取的是二维数组的元素
            String[] ps = persons2[i];

            //遍历二维数组的元素（一维数组）
            for (int j = 0; j < ps.length; j++) {

                System.out.print(ps[j] + " ");
            }

            System.out.println();
        }

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

        //先遍历二维数组 -- 二维数组的元素是一维数组
        for (int i = 0; i < persons2.length; i++) {
            //遍历二维数组的元素（一维数组）
            for (int j = 0; j < persons2[i].length; j++) {
                System.out.print(persons2[i][j] + " ");
            }

            System.out.println();
        }



        //二维数组的元素的默认是(二维数组的元素是一维数组而一维数组是引用数据类型)：null


    }
}

二维数组的动态与赋值

/*
    二维数组
 */
public class ArrayTest2 {

    public static void main(String[] args) {

        //动态初始化： 先通过指定数组的长度的方式进行初始化 后面再赋值
        String[][] ps = new String[3][2];//二维数组的长度为3  二维数组的元素（一维数组）的长度为2


        String[][] ps2 = new String[3][];//二维数组的长度为3

        System.out.println(ps2[0]);
        System.out.println(ps2[1]);
        System.out.println(ps2[2]);

        //给二维数组的元素赋值
        ps2[0] = new String[2];
        ps2[1] = new String[3];
        ps2[2] = new String[2];

        //给二维数组的元素的元素赋值
        ps2[0][1] = "龙哥";
        ps2[2][0] = "海哥";


        //遍历二维数组
        for (int i = 0; i < ps2.length; i++) {
            for (int j = 0; j < ps2[i].length; j++) {
                System.out.print(ps2[i][j] + " ");
            }
            System.out.println();
        }

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

        System.out.println(ps2[0]);
        System.out.println(ps2[1]);
        System.out.println(ps2[2]);
    }

二维数组内存图

liang79096
关注
Java基础复习day03数组
12-11
Java基础复习day03数组 Java数组是一种数据类型，引用类型，用于存放一组数据的数据结构。数组的定义、创建、访问、长度属性、遍历、常用Arrays类、二维数组、方法递归调用经典案例、变量源码教程等。 一、数组的...
java实现：给定两个一维数组，将这两个数组元素大小排序后生成一个新的数组
weixin_52713288的博客
12-23 900
java：给定两个一维数组，将这两个数组元素大小排序后生成一个新的数组 public static void main(String[] args) { int[] A = {1, 2, 8, 10, 15}; int[] B = {3, 4, 5, 6, 7}; int[] AB = MY(A, 5, B, 5); for (int i = 0; i < AB.length; i++) { System.out.print(AB[i] + " "); } } public static int[]
java第四章数组初识排序
12-26
例如，定义一个2x3的二维数组： ```java int[][] multiDimArray = new int[2][3]; ``` 多维数组的遍历和操作相对复杂，需要考虑每一维度的下标。 总结：数组是Java中处理批量数据的基础工具，了解其概念、定义、...
Java实验报告一java基础.doc
06-27
- 在Java中，二维数组可以通过声明一个一维数组的数组来创建，例如`int[][] array = new int[2][3];` - 生成0到100之间的随机整数，可以使用`(int)(Math.random() * 100)`。 - 对数组进行排序，Java提供了`Arrays...
Day07-嵌套循环和方法.rar
06-17
假设我们有一个二维数组，我们想要打印出所有元素。在这种情况下，可以使用两个for循环，第一个循环遍历数组的行，第二个循环遍历列： ```java int[][] array = new int[3][4]; // 初始化数组... for (int i = 0; i...
7DaysPerTopicChallenge-Day2-Array
03-13
数组分为一维数组、二维数组（矩阵）、多维数组和动态数组等不同类型。一维数组是最基础的形式，类似于线性的元素列表。二维数组则可以看作是由一维数组组成的表格，常用于处理表格数据。多维数组可以扩展到更高维度...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 99
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
刷题---顺序表算法题
weixin_63997543的博客
11-11 256
顺序算法题----力扣刷题
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 222
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
JAVA-01-变量
LJH_laura_li的博客
11-08 465
在方法、构造函数或块内部定义的变量。
JAVA学习接口案例实例
shangan_3的博客
11-08 203
【代码】JAVA学习接口案例实例。
Spring资源加载模块，原来XML就这，活该被注解踩在脚下 手写Spring第六篇了
mkii_hong的博客
11-11 634
Spring通过【资源】和【资源加载】帮我们找到这些配置文件然后通过大厨解析配置最后把"菜"（Bean）放到"厨房"（容器）里本文由 https://github.com/hongweihao/small-spring/tree/6_resource_load 赞注完成本文完 | 求赞求关注求转发!
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 672
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 341
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
SpringMVC
hi_zf的博客
11-11 95
处理器映射器: HandlerMapping。处理器适配器: HandlerAdapter。视图解析器: ViewResolver。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1009
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
ArkTS--应用状态
qq_63946637的博客
11-10 546
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
greendao使用封装
白高林的专栏
11-07 453
greenDAO
JavaScript 高阶总结
qq_43787947的博客
11-11 438
JavaScript 高级总结
Java基础教程day05-06：掌握数组、类与对象概念
资源摘要信息:"Java入门基础学习资料day05-06" Java是一种广泛使用的计算机编程语言，被设计用于开发跨平台应用程序。它以面向对象和平台无关性为特点，是目前最流行的编程语言之一。本次提供的学习资料涵盖Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值