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

liang79096

已于 2024-03-28 14:47:24 修改

阅读量152

点赞数 3

文章标签： java 开发语言

于 2024-03-27 18:48:04 首次发布

本文链接：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));
    }
}

冒泡排序

掌握逐个比较取最大值

5	3	6	4	2


3	5	6	4	2
3	5	6	4	2
3	5	4	6	2
3	5	4	2	6


3	5	4	2	6
3	4	5	2	6
3	4	2	5	6

3	4	2	5	6
3	2	4	5	6

2	3	4	5	6

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]);
    }

二维数组内存图