小王java学习打卡day04——数组，排序，重载

最新推荐文章于 2022-11-08 16:08:56 发布
最新推荐文章于 2022-11-08 16:08:56 发布
阅读量233 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 学习打卡 文章标签： 蓝桥杯 java p2p
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/w1099938370/article/details/124626201
这篇博客介绍了Java中的数组拷贝和扩容，使用Arrays工具类进行操作，并探讨了二维数组。接着讲解了选择排序和二分查找算法。此外，还详细阐述了方法的概念，包括可变参数和方法的重载，提供了多个示例来说明如何在不同场景下应用这些概念。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数组拷贝及扩容

  1. 首先得有两个数组

  2. 的指导从哪拷贝到哪，拷贝多长

    需求：从源数组拷贝第二个元素到第四个元素，到目标数组里面

/*需求：从源数组拷贝第2个元素到第4个元素，到目标数组里面*/
public class CopyDemo {
    public static void main(String[] args) {
        int[] ages = {15, 12, 56, 45, 2, 56, 15, 1, 8, 4};
        int srcPos =2; //起始位置
        int index =3;
        int[] newAges = new int [3];
        int destPos=0;
        for (int i = srcPos; i < srcPos+index; i++) {
            newAges[destPos++]=ages[i];
//            destPos++;
        }
        for (int i = 0; i < newAges.length; i++) {
            System.out.println(newAges[i]);
        }
    }
}
​

数组工具类Arrays

需求： int[] ages = {15, 12, 56, 45, 2, 56, 15, 1, 8, 4}; 打印出来变成[ 15, 12, 56, 45, 2, 56, 15, 1, 8, 4 ]

/*
 * 需求：  int[] ages = {15, 12, 56, 45, 2, 56, 15, 1, 8, 4};  打印出来变成[  15, 12, 56, 45, 2, 56, 15, 1, 8, 4 ]
 * */
public class ArrayPrintDemo {
    public static void main(String[] args) {
        int[] ages = {15, 12, 56, 45, 2, 56, 15, 1, 8, 4};
        String ret = "[";
        for (int i = 0; i < ages.length; i++) {
            //最后一个元素 不拼接 ,
            if(i==ages.length-1){
                ret = ret + ages[i];
            }else {
                ret = ret + ages[i] + ",";
            }
        }
        System.out.println(ret+"]");
    }
}
​

查看一个类的所有方法 alt+7

  • Arrays.toString

二维数组

//定义
int[][]arrays = new int [] [] {{1,2,5,6,9,8,4},{6,6,7,9,5,4,12,3}};
int[][]arrays = {{1,2,5,6,9,8,4},{6,6,7,9,5,4,12,3}};
int[][]arrays = new int [3] [6];
​
//需求：如何遍历二维数组
依然是for循环，只不过第一次拿到的是一维数组，只有把拿到的值再循环，才能得到具体的元素
​
/*
 * 二维数组的训练
 * //需求：如何遍历二维数组
 * */
public class TwoArraysDemo {
    public static void main(String[] args) {
        int[][] arrays = new int[][]{{1, 2, 5, 6, 9, 8, 4}, {6, 6, 7, 9, 5, 4, 12, 3}};
//        int[][] arrays1 = {{1, 2, 5, 6, 9, 8, 4}, {6, 6, 7, 9, 5, 4, 12, 3}};
//        int[][] arrays2 = new int[3][6];
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(Arrays.toString(arrays[i]));
            //[1, 2, 5, 6, 9, 8, 4]
            //[6, 6, 7, 9, 5, 4, 12, 3]
        }
        for (int i = 0; i < arrays.length; i++) {
            int[] array = arrays[i];
​
            for (int i1 = 0; i1 <array.length; i1++) {
                int i2 = array[i1];
                System.out.print(i2+",");
//                System.out.println();
            }
        }
    }
}
​

算法

需求：定义两个变量，交换两个变量的值

/*
 * 需求：定义两个变量，交换两个变量的值
 * */
public class SwapDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int temp = a;
        a = b;
        b = temp;
        System.out.println(a + "," + b);
​
    }
}
​

冒泡排序

/*
* 冒泡排序  c
* */
public class BubbleSortDemo {
    public static void main(String[] args) {
        int []heights = {8,6,7,4,1,9};
        //比较了五次
        for (int i = 1; i < heights.length-1; i++) {
            //第一次比较
            if(heights[i-1]>heights[i]){
                int temp= 0;
                temp=heights[i-1];
                heights[i-1]=heights[i];
                heights[i]=temp;
            }
        }
        //第二次比较
        for (int i = 1; i < heights.length-2; i++) {
            //第一次比较
            if (heights[i - 1] > heights[i]) {
                int temp = 0;
                temp = heights[i - 1];
                heights[i - 1] = heights[i];
                heights[i] = temp;
            }
        }
        //第三次比较
        for (int i = 1; i < heights.length-3; i++) {
            //第一次比较
            if (heights[i - 1] > heights[i]) {
                int temp = 0;
                temp = heights[i - 1];
                heights[i - 1] = heights[i];
                heights[i] = temp;
            }
        }
        //第四次比较
        for (int i = 1; i < heights.length-4; i++) {
            //第一次比较
            if (heights[i - 1] > heights[i]) {
                int temp = 0;
                temp = heights[i - 1];
                heights[i - 1] = heights[i];
                heights[i] = temp;
            }
        }
​
        System.out.println(Arrays.toString(heights));
    }
}
​
/*
 * 冒泡排序   升级循环版
 * */
public class BubbleSortDemo2 {
    public static void main(String[] args) {
        int[] heights = {18, 6, 78, 4, 51, 97};
        //比较了length-1次
        for (int x = 1; x < heights.length; x++) {
            for (int i = 1; i < heights.length - x; i++) {
                if (heights[i - 1] > heights[i]) {
                    int temp = 0;
                    temp = heights[i - 1];
                    heights[i - 1] = heights[i];
                    heights[i] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(heights));
    }
}
​

选择排序

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

/*
* 选择排序
* */
public class SelectionDemo {
    public static void main(String[] args) {
        int[] heights = {18, 6, 78, 4, 51, 97};
        for (int i = 0; i < heights.length-1; i++) {
            if(heights[0]>heights[i+1]){
                int temp = heights[0];
                heights[0]=heights[i+1];
                heights[i+1]=temp;
            }
        }
​
        System.out.println(Arrays.toString(heights));
        for (int i = 1; i < heights.length-1; i++) {
            if(heights[1]>heights[i+1]){
                int temp = heights[1];
                heights[1]=heights[i+1];
                heights[i+1]=temp;
            }
        }
        System.out.println(Arrays.toString(heights));
        for (int i = 2; i < heights.length-1; i++) {
            if(heights[2]>heights[i+1]){
                int temp = heights[2];
                heights[2]=heights[i+1];
                heights[i+1]=temp;
            }
        }
        System.out.println(Arrays.toString(heights));
        for (int i = 3; i < heights.length-1; i++) {
            if(heights[3]>heights[i+1]){
                int temp = heights[3];
                heights[3]=heights[i+1];
                heights[i+1]=temp;
            }
        }
        System.out.println(Arrays.toString(heights));
        for (int i = 4; i < heights.length-1; i++) {
            if(heights[4]>heights[i+1]){
                int temp = heights[4];
                heights[4]=heights[i+1];
                heights[i+1]=temp;
            }
        }
        System.out.println(Arrays.toString(heights));
    }
}
​

二分查找法

/*
* 二分查找法
* */
public class BinarySearchDemo {
    public static void main(String[] args) {
        int []heights = {8,6,7,4,1,9};
        int Search = 9;
        int min = 0;
        int max = heights.length;
       while (min <= max){
            System.out.println(min +"------"+max);
           //永远找一般的索引
            int mid = (min +max)/2;
            int midValue =heights[mid];
            if(midValue>Search){
                //如果大于，就往右边找
                max = mid;
            }else if(midValue<Search){
                //如果小于，就往左边找
                min=mid;
            }else {
                System.out.println(mid);
                break;
            }
            }
        }
    }
​

方法

解决代码重复的问题

定义：修饰符 +返回值类型 + 方法名称 + （形式参数）{  
        方法体
}
​
​
/*
* 方法定义练习
* 打印 helloworld 一百次
* */
public class MethodDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            print();
        }
    }
    //参考主方法
    //自定义方法
    public static void print(){
        System.out.println("helloWorld!!!!");
    }
}
​

详细讲解方法

//    修饰符           返回值   方法名称    形式参数
     public   static  void  PrintString(String str){0
        System.out.println("我需要打印"+ str);
    }
}

方法的可变参数

    public static int addSum(int...arr){
        int sum = 0;
        for (int i : arr) {
            sum +=i;
        }
        return sum;
    }

方法的重载

方法重载:方法重载就是方法名称重复，加载参数不同。

  1. 需求：定义一个求两个正整数的加法计算器，定义一个 求浮点型 double 的计算器

  2. 需求：在同一个类中，分别去打印 String int double 类型

/*
* 方法的重载
* 需求：定义一个求两个正整数的加法计算器，定义一个  求浮点型 double 的计算器
* */
public class OverloadDemo {
    public static void main(String[] args) {
        System.out.println(getSum(2, 5));
        System.out.println(getSum(2.4, 3.3));
        System.out.println(getSum(2, 66, 32));
    }
    public static int getSum(int num1,int num2){
        return num1+num2;
    }
    public static double getSum(double num1,double num2){
        return num1+ num2;
    }
    public static int getSum(int num1,int num2,int sum3){
        return num1+num2+sum3;
    }
}
​

注意，Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两个重载的方法

算法与数据结构【30天】集训营——数组按行（列）为主序存储题型技巧求解、广义表知识点（10）
迷茫与徘徊只会让你陷入绝境，欢迎私信博主，带你开始提升变现价值！
10-15 972
该类题目，首先需要明确的是是按照行还是列进行主存放，如果是行进行主存放，那么就是该行之前的元素个数乘以数组中列的元素个数，然后加上该列之前的元素个数之和，然后乘以每个元素所占的单位。这里唯一需要注意的就是，在确定题目中所求的数组的元素之前的个数的时候，我们需要考虑该起点位置在哪里？比如起点是从-1开始到9，LOC【7,4】，-1 0 1 2 3 4 5 6 7 ，这里如果是按照行序主存放，那么该元素之前的个数为：8个起点很重要！
【数组——LeetCode刷题笔记C++】持续更新
qq_40313533的博客
08-25 1003
刷题记录
java重载排序_Java 排序总结 - MingjaLee的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_39884877的博客
02-26 146
Arrays.sort()public static void sort(int[] a) Sorts the specified array into ascending numerical order. Implementation note: The sorting algorithm is a Dual-Pivot Quicksort by Vladimir Yaroslavskiy, J...
数组排序【c++函数重载】
m0_60891676的博客
03-22 1141
Description 定义两个重载函数，分别对整数数组和字符串数组用选择法从小到大排序，数组大小不超过10个元素，最后输出排序后的数据。 Input 第一行的第一个整数表示数组元素个数n，后面n个整数为数组元素的值，数据之间用空格分开 第二行的第一个整数表示数组元素个数n，后面n个字符串为数组元素的值，数据之间用空格分开，注意字符串里不包含空格 Output 第一行输出排序后的整数，第二行输出排序后的字符串，数据之间用空格分开（每行输出的最后一个数据后的空格需要单独处理） Sa.
java中重载定义_浅谈java实现重载的方法
weixin_39888943的博客
02-24 1044
重载(重新载选方法)：java允许在一个类中，存在多个方法拥有相同的名字，但在名字相同的同时，必须有不同的参数，这就是重载，编译器会根据实际情况挑选出正确的方法，如果编译器找不到匹配的参数或者找出多个可能的匹配就会产生编译时错误，这个过程被称为重载的解析。重载包括：普通方法的重载和构造方法的重载方法：即函数(文中我们统称之为“方法”)，是一个固定的一个程序段，或称其为一个子程序，它在可以实现固定运...
Java 数组的 创建，填充，复制，排序，重载
长生猫的记事本
04-06 200
package cs; import java.util.Arrays; //import java.util.regex.Pattern; //Matcher //import java.util.regex.Matcher; //Pattern和 public class Zuoye8 { public static void main(String[] args){ int a...
Java中使用数组完成学生成绩统计的多种实现代码清单.pdf
07-11
3. **数组排序**：Java中的`Arrays.sort()`方法可以对一维数组进行升序排序，对于自定义类型，需要提供比较器。 4. **计算平均值**：通过累加所有成绩并除以学生人数来计算平均分。 5. **数组复制**：`Arrays....
Java中数组实例---冒泡排序.pdf
07-11
这个例子展示了如何在Java中使用冒泡排序对一个长度为10的随机数组进行升序排列。通过外层循环控制轮数，内层循环实现两两比较和交换，以及一个标志位判断是否提前结束排序，从而实现了冒泡排序算法的基本功能。
Java数组排序中Comparator接口实现自定义排序
iCoding91
09-22 4237
1、为节点排序。节点由3个字段组成，包括num ,weight ,height 。先按照weight升序排序，再按照height降序排序。 2、使用Comparator接口规则：编写多个排序方式类实现Comparator接口，并重写新Comparator接口中的compare()方法。升序是前者减去后者，降序是后者减去前者。 3、代码测试：同时也是牛客网中某题。 题目描述： 搜狐员
Java List<>排序——重载Collections.sort方法
白小冬的专栏
06-13 2449
前段时间用到了List的排序，可以直接重载Collections类中的sort()方法，故总结如下： 设有记录类Record public class Record { private String name; /** 时间，格式yyyyMM */ private String date; public String getName() {
方法的重载，方法的调用和数组，及数组的排序
qq_40975027的博客
11-09 432
Java中方法重载的实例及数组，数组排序 部分异常
JAVASE（复习）——方法重载、数组篇
皮皮治不痞痞
11-08 506
数组下标是0开始，定义长度是索引减一。arr.length计算的是行数。数组下标重0开始，内存连续。
内部排序算法
dl156001的博客
12-25 183
typedef struct{ int key; int Info; }RedType; typedef struct{ RedType* r; int length; }Sqlist; void InsertSort(Sqlist &L); void BinInsertSort(Sqlist &L); v...
Java Array.sort()两种重载的排序方法
ystyaoshengting的专栏
02-21 7220
package com.practice.ch10;import java.util.Arrays;public class Result implements Comparable{ int point;  //成绩 int no;       //学号 String name;   //姓名 public Result(int point,int no,String name) {  this.point = point;  this.no = no;  this.name = name; } publ
java sort 重载_Java Array.sort()两种重载的排序方法
weixin_39773447的博客
02-12 443
Array.Sort()方法是根据元素的自然顺序对指定的对象数组按升序进行排序，但是如果如果数组中的对象不是能直接进行比较的话，那么会报错，例如学生的成绩进行排序，对象是学生，具有成绩，学号，姓名的属性。如果想对学生的成绩进行排序，有两种方法：1.实现Comparable接口，并覆盖compareTo方法，按照你的意思进行排序2.实现Comparator接口，并覆盖compare方法，按照你的意思...
Java对象重载排序函数，实现排序
guochao6531的博客
03-02 1565
Java基本语法回顾在对象生成过程中，我们难免会牵扯到对象之间排序的问题，在Java语言中提供了自我排序的方式—Comparable函数，我们继承并重载对象Comparable函数，实现了对象之间的排序，并在此回顾了List的简单实用方法。## 实现代码 ## 在这里，我们以Employee员工的三个属性进行测试，工号，姓名，年龄。 如下：public class Employee
java重载实现排序_Java List重载Collections.sort方法排序
weixin_30189603的博客
03-02 363
最近做游戏中的背包系统中的一个快速整理接口，其实就是按照物品的几个指定特性进行排序后更新背包中物品位置。找了一下，发现重载Collections.sort方法可以实现对List中的数据根据其存储的数据表字段进行排序。其实还有一种方法，就是对List中对象实现Compareable接口。这种方法没有使用。需要排序的规则是先按类型排(升序)，类型相同的话看等级(降序，等级高的在前)，等级相同的看品质(...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值