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

最新推荐文章于 2022-11-08 16:08:56 发布
原创 最新推荐文章于 2022-11-08 16:08:56 发布 · 244 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#蓝桥杯 #java #p2p

这篇博客介绍了Java中的数组拷贝和扩容，使用Arrays工具类进行操作，并探讨了二维数组。接着讲解了选择排序和二分查找算法。此外，还详细阐述了方法的概念，包括可变参数和方法的重载，提供了多个示例来说明如何在不同场景下应用这些概念。

数组拷贝及扩容

  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 1002
该类题目，首先需要明确的是是按照行还是列进行主存放，如果是行进行主存放，那么就是该行之前的元素个数乘以数组中列的元素个数，然后加上该列之前的元素个数之和，然后乘以每个元素所占的单位。这里唯一需要注意的就是，在确定题目中所求的数组的元素之前的个数的时候，我们需要考虑该起点位置在哪里？比如起点是从-1开始到9，LOC【7,4】，-1 0 1 2 3 4 5 6 7 ，这里如果是按照行序主存放，那么该元素之前的个数为：8个起点很重要！
java重载排序_Java 排序总结 - MingjaLee的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_39884877的博客
02-26 158
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 1163
Description 定义两个重载函数，分别对整数数组和字符串数组用选择法从小到大排序，数组大小不超过10个元素，最后输出排序后的数据。 Input 第一行的第一个整数表示数组元素个数n，后面n个整数为数组元素的值，数据之间用空格分开 第二行的第一个整数表示数组元素个数n，后面n个字符串为数组元素的值，数据之间用空格分开，注意字符串里不包含空格 Output 第一行输出排序后的整数，第二行输出排序后的字符串，数据之间用空格分开（每行输出的最后一个数据后的空格需要单独处理） Sa.
java中重载定义_浅谈java实现重载的方法
weixin_39888943的博客
02-24 1062
重载(重新载选方法)：java允许在一个类中，存在多个方法拥有相同的名字，但在名字相同的同时，必须有不同的参数，这就是重载，编译器会根据实际情况挑选出正确的方法，如果编译器找不到匹配的参数或者找出多个可能的匹配就会产生编译时错误，这个过程被称为重载的解析。重载包括：普通方法的重载和构造方法的重载方法：即函数(文中我们统称之为“方法”)，是一个固定的一个程序段，或称其为一个子程序，它在可以实现固定运...
Java 数组的 创建，填充，复制，排序，重载
长生猫的记事本
04-06 211
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...
微信小程序——数组操作 (增加删除修改遍历）map、filter、forEach、find的用法、二维数组，排序，求和、指定长度数组赋值
热门推荐
wy313622821的博客
06-23 4万+
Array.push() ->在数组后面继续插入内容Array.pop() ->拿走数组最后一个内容Array…shift()->拿走数组的第一个内容 (unshift也是拿走最后一个)Array.reverse()->对数组从大到小排列Array.sort()->对数组从小到大排列**Array.splice(起始位置 , 位数,”增添内容”)->从数组中取出以起始位置开始的位数的内容，并写入增添内容，可用来删除内容与替换,例如people.aplice(1，2，“name”)
Java中使用数组完成学生成绩统计的多种实现代码清单.pdf
07-11
3. **数组排序**：Java中的`Arrays.sort()`方法可以对一维数组进行升序排序，对于自定义类型，需要提供比较器。 4. **计算平均值**：通过累加所有成绩并除以学生人数来计算平均分。 5. **数组复制**：`Arrays....
【数组——LeetCode刷题笔记C++】持续更新
qq_40313533的博客
08-25 1171
刷题记录
Java中数组实例---冒泡排序.pdf
07-11
这个例子展示了如何在Java中使用冒泡排序对一个长度为10的随机数组进行升序排列。通过外层循环控制轮数，内层循环实现两两比较和交换，以及一个标志位判断是否提前结束排序，从而实现了冒泡排序算法的基本功能。
Java List<>排序——重载Collections.sort方法
白小冬的专栏
06-13 2480
前段时间用到了List的排序，可以直接重载Collections类中的sort()方法，故总结如下： 设有记录类Record public class Record { private String name; /** 时间，格式yyyyMM */ private String date; public String getName() {
方法的重载，方法的调用和数组，及数组的排序
qq_40975027的博客
11-09 445
Java中方法重载的实例及数组，数组排序 部分异常
JAVASE（复习）——方法重载、数组篇
皮皮治不痞痞
11-08 528
数组下标是0开始，定义长度是索引减一。arr.length计算的是行数。数组下标重0开始，内存连续。
内部排序算法
dl156001的博客
12-25 196
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 7343
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 458
Array.Sort()方法是根据元素的自然顺序对指定的对象数组按升序进行排序，但是如果如果数组中的对象不是能直接进行比较的话，那么会报错，例如学生的成绩进行排序，对象是学生，具有成绩，学号，姓名的属性。如果想对学生的成绩进行排序，有两种方法：1.实现Comparable接口，并覆盖compareTo方法，按照你的意思进行排序2.实现Comparator接口，并覆盖compare方法，按照你的意思...
Java对象重载排序函数，实现排序
guochao6531的博客
03-02 1599
Java基本语法回顾在对象生成过程中，我们难免会牵扯到对象之间排序的问题，在Java语言中提供了自我排序的方式—Comparable函数，我们继承并重载对象Comparable函数，实现了对象之间的排序，并在此回顾了List的简单实用方法。## 实现代码 ## 在这里，我们以Employee员工的三个属性进行测试，工号，姓名，年龄。 如下：public class Employee
java重载实现排序_Java List重载Collections.sort方法排序
weixin_30189603的博客
03-02 392
最近做游戏中的背包系统中的一个快速整理接口，其实就是按照物品的几个指定特性进行排序后更新背包中物品位置。找了一下，发现重载Collections.sort方法可以实现对List中的数据根据其存储的数据表字段进行排序。其实还有一种方法，就是对List中对象实现Compareable接口。这种方法没有使用。需要排序的规则是先按类型排(升序)，类型相同的话看等级(降序，等级高的在前)，等级相同的看品质(...
全面掌握Java开发：项目、Web及大数据学习路径
从给定文件信息来看，文件"java学习路线（项目开发、web方向、大数据方向）.rar"中所涉及的知识点主要集中在Java编程语言的学习路径上，按照项目开发、Web方向、大数据方向三个子方向进行划分。接下来，我将详细说明...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值