Java数组、排序、集合

最新推荐文章于 2024-07-22 08:37:45 发布
最新推荐文章于 2024-07-22 08:37:45 发布
阅读量105 收藏 1
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52354446/article/details/118825764
版权
本文详细介绍了Java中的数组，包括定义、赋值、获取长度及二维数组的使用。接着讲解了冒泡排序和选择排序的原理及实现。此外，还探讨了Java集合框架，包括List、Set接口及其实现类的特性，并提供了相关练习题。
摘要由CSDN通过智能技术生成

一、数组

数组是一个变量，存储相同数据类型的一组数据。

1.定义数组：

类型[]  数组名  =  new  类型[长度];

类型[]  数组名； 数组名 = new 类型[长度]；

类型[]  数组名  =  new  类型[]{值1，值2，值3};

类型[]  数组名  =  {值1，值2，值3};

2.数组赋值

scores[0] = 89;
scores[1] = 79;
scores[2] = 76;

int[ ] scores = {89, 79, 76};
int[ ] scores = new int[ ]{89, 79, 76};

//键盘输入赋值
Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){
     scores[i] = input.nextInt();
}

3.获取数组长度：

数组名.length

练习1：

有一个数列：8，4，2，1，23，344，12。题目要求：循环输出数列的值， 求数列中所有数值的和。猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数。

方法一：

public class ShuZu {
    public static void main(String[] args) {
        int[] number = new int[]{8, 4, 2, 1, 23, 344, 12};
        int sum = 0;
        for (int i = 0; i < 7; i++) {
            System.out.println("number[" + i + "] = " + number[i]);
            sum += number[i];
        }
        System.out.println("和为：" + sum);

        Scanner number2 = new Scanner(System.in);
        System.out.println("请输入一个随机数：");
        int n = number2.nextInt();
        int m = 0;
        for (int i = 0; i < 7; i++) {
            if (n == number[i]) {
                System.out.println("该数组包含该随机数");
                break;
            }
            m++;
        }
        if(m == 7)
            System.out.println("该数组不包含该随机数");
    }
}

 方法二：

import javax.xml.transform.Source;
import java.util.Scanner;

public class DemoF {
    public static void main(String[] args) {
        int[] number = { 8,4,2,1,23,344,12};

        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个数值:");
        int locNum =  input.nextInt();

        int sum = 0;
        boolean isOk = false;

        for (int i = 0; i < number.length; i++) {
            System.out.println(number[i]);

            sum += number[i];

            if(locNum == number[i]){
                isOk = true;
            }
        }
        System.out.println("和："+sum);
        System.out.println(isOk?"包含:"+locNum:"不包含:"+locNum);

    }
}

4.二维数组

存值语法：

数组名[下标1][下标2] = 值;

二、冒泡排序和选择排序

1.冒泡排序

原理：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

 算法实现：

int[] number = {8, 4, 2, 1, 23, 344, 12};
for (int i = 0; i < number.length - 1; i++) {
    for (int k = 0; k < number.length - 1 - i; k++) {
        if (number[k] > number[k + 1]) {
            int tmp = number[k];
            number[k] = number[k + 1];
            number[k + 1] = tmp;
        }
     }
}
System.out.println(Arrays.toString(number));

2.选择排序

原理：

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

代码实现：

int[] number = {8, 4, 2, 1, 23, 344, 12};
int index;
for (int i = 0; i <   number.length - 1; i++) {
    index = i;
    for (int k = i; k < number.length; k++) {
        if(number[k] < number[index]){
            index = k;
        }
    }
    int tmp = number[i];
    number[i] = number[index];
    number[index] = tmp;
}
System.out.println(Arrays.toString(number));

练习2：

int[] numbers = {8,5,9,87,7,12,85,32,112,47,28,4,55,2,56,74}; 要求 将 29 按照顺序 插入到当前 数组中。实现思路（创建 大于当前numbers数组一位长度的新数组，将数据按照顺序导入到新的数组中，使用循环找出 29 应该所在的下标， 将 29 所在下标后的数据 全部后移一位， 将 29 插入新的数组。）

方法一：

import java.util.Arrays;

public class HuanShuZu {
    public static void main(String[] args) {
        int[] numbers = {8,5,9,87,7,12,85,32,112,47,28,4,55,2,56,74};
        System.out.println("原数组："+ Arrays.toString(numbers));
        Arrays.sort(numbers);
        System.out.println("排序后："+Arrays.toString(numbers));

        int[] newnumbers = Arrays.copyOf(numbers, numbers.length+1);
        System.out.println("复制后："+Arrays.toString(newnumbers));

        int n = 0;
        int num = 29;
        for (int i = 0; i < newnumbers.length; i++) {
            if(num < newnumbers[i]){
                n=i;
                break;
            }
        }
        for (int i = newnumbers.length-1; i > n; i--) {
            newnumbers[i] = newnumbers[i-1];
        }
        newnumbers[n] = num;
        System.out.println("插入后：" + Arrays.toString(newnumbers));
    }
}

方法二：

import java.util.Arrays;

public class DemoB {
    public static void main(String[] args) {
        int[] numbers = {8,5,9,87,7,12,85,32,112,47,28,4,55,2,56,74};
        // 显示原数组
        System.out.println("原数组："+Arrays.toString(numbers));
        Arrays.sort(numbers);//完成排序
        System.out.println("排序后数组："+Arrays.toString(numbers));

//        int[] newNumbers = new int[numbers.length + 1];
//        for (int i = 0; i <numbers.length ; i++) {
//            newNumbers[i] = numbers[i];
//        }

        //Arrays.copyOf(原数组,长度)  复制数组元素到一个新的数组中
        int[] newNumbers = Arrays.copyOf(numbers,numbers.length + 1);
        //复制数组 长度 +1(为 29 元素 腾出位置)
        System.out.println("复制后的数组："+Arrays.toString(newNumbers));

        //声明 变量 index 标记29的位置 预计29是最小的 下标为0
        int index = 0;
        int num = 29;// 需要插入到数组中的元素
        for (int i = 0; i < newNumbers.length ; i++) {
            if(num <newNumbers[i]){
                //记录 插入元素应该所在的下标
                index = i;
                break;
            }
        }
        //将num 元素所在下标的 所有后位元素 后移一位
        for (int i = newNumbers.length - 1; i > index ; i--) {
                newNumbers[i] = newNumbers[i-1];
        }
        //将元素放入新的数组
        newNumbers[index] = num;

        System.out.println("插入元素后的数组："+Arrays.toString(newNumbers));

        // 倒序显示数组
        for (int i = newNumbers.length-1 ; i >=0 ; i--) {
            System.out.print(newNumbers[i]+",");

        }

    }
}

补：反转排序

import java.util.Arrays;

public class DemoC {
    public static void main(String[] args) {
        int[] numbers = {8,5,9,87,7,12,85,32,112,47,28,4,55,2,56,74};
        // 反转排序
        for (int i = 0; i < numbers.length / 2; i++) {
            int temp = numbers[i];
            numbers[i] =numbers[numbers.length-i-1];
            numbers[numbers.length-i-1] = temp;
        }
        System.out.println(Arrays.toString(numbers));

    }
}

三、集合

1.List接口

List 接口存储一组不唯一，有序（插入顺序）的对象

List下有

ArrayList：查询快；

Vector：查询快，安全；

LinkedList：增删快。

定义代码：

ArrayList<String> arrayList = new ArrayList<>();
Vector<String> vector= new Vector<>();
LinkedList<String> linkedList= new LinkedList<>();
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class DemoA {
    public static void main(String[] args) {
        // 通过List接口 创建 ArrayList集合
        // 基本数据类型  byte short int long  float double boolean  char
        //List<泛型> 指定泛型后 只能放入符合泛型类型的数据进入集合中
        //未指定泛型 类型默认为 Object 可以存储任何类型

        List<String> list = new ArrayList<>();

        // 向集合中增加数据   使用了 ArrayList的 add(值) 返回结果为 boolean true 添加成功  false 添加失败

        boolean isOk = list.add("张三");
        System.out.println(isOk);
        list.add("李四");
        list.add("王五");
        // 新增数据到固定的下标
        list.add(1,"测试数据");

        System.out.println("获取集合长度:" + list.size());
        System.out.println("根据下标获取集合元素:"+list.get(2));
        // 通过contains(值) 检测集合中是否存在 对应值  存在 true  不存在 false
        System.out.println("检查集合中是否存在王五:" + list.contains("王五"));
        //list.remove(3);//通过下标删除 集合元素
        list.remove("王五"); //通过元素 删除集合中的元素
        System.out.println("检查集合是否为空："+list.isEmpty());
//        list.clear(); //清空集合

        //遍历集合
        for (String str:list) {
            System.out.println(str);
        }

        
        List<String> newList =  list.subList(0,2);//取集合第0位到第2位
        for (String str:newList) {
            System.out.println(str);
        }

        //
        Object[] strs = list.toArray();
        System.out.println(Arrays.toString(strs));

        //
        Iterator<String> iterator = list.iterator();
        // iterator.hasNext() 返回boolean true 存在下一条数据
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }

    }
}
import java.util.ArrayList;
import java.util.List;

public class DemoD {
    public static void main(String[] args) {
        List<String> listA = new ArrayList<>();
        listA.add("A");
        listA.add("B");
        listA.add("C");
        List<String> listB = new ArrayList<>();
        listB.add("B");
        listB.add("C");
        listB.add("D");

        //获取 lsitA  与  listB的交集数据
//        listA.retainAll(listB);

        //获取 listA 与 listB的差集
        listA.removeAll(listB);

        //将listA 与 listB 合并
        listA.addAll(listB);

        //显示集合listA
        System.out.println(listA);
    }
}

2.Set接口

Set 接口存储一组唯一，无序的对象

Set下有

HashSet：无序，唯一；

LinkedHashSet：插入有序，唯一；

TreeSet：有序，唯一。

 定义代码：

HashSet<String> hashSet = new HashSet<>();
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
TreeSet<String> treeSet = new TreeSet<>();

应用： 

import java.util.*;

public class DemoE {
    public static void main(String[] args) {
        //通过set接口创建 HashSet
        Set<String> set = new HashSet<>();

        // 向集合中增加数据   使用了 ArrayList的 add(值) 返回结果为 boolean true 添加成功  false 添加失败
        boolean isOk = set.add("张三");
        System.out.println(isOk);
        set.add("李四");
        set.add("王五");
        set.add("王五");
        set.add("王五");

        System.out.println("获取集合长度:" + set.size());
        // 通过contains(值) 检测集合中是否存在 对应值  存在 true  不存在 false
        System.out.println("检查集合中是否存在王五:" + set.contains("王五"));
//        set.remove("王五"); //通过元素 删除集合中的元素
        System.out.println("检查集合是否为空："+set.isEmpty());
//        set.clear(); //清空集合
        for (String str:set) {
            System.out.println(str);
        }
        System.out.println("--------------------------------");
        Object[] strs = set.toArray();
        System.out.println(Arrays.toString(strs));
        System.out.println("--------------------------------");
        Iterator<String> iterator = set.iterator();
        // iterator.hasNext() 返回boolean true 存在下一条数据
        while (iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
        }
    }
}

3.Map接口

Map接口存储一组键值对象，提供key到value的映射 
import java.util.*;

public class DemoF {
    public static void main(String[] args) {
        // 通过 map接口 创建了HashMap
        Map<String, String> stringMap = new HashMap<>();
        // 将数据保存到map集合中
        stringMap.put("ES","西班牙 ");
        stringMap.put("NL","荷兰");
        stringMap.put("AF","阿富汗-测试");

        stringMap.put("AF","阿富汗");
        stringMap.put("AR","阿根廷");
        stringMap.put("AU","澳大利亚");

        //通过key 获取value
        System.out.println("通过get(key)获取value:"+stringMap.get("AF"));

        System.out.println("通过size()方法获取map 集合长度："+stringMap.size());
        System.out.println("集合是否为空："+stringMap.isEmpty());
        System.out.println("通过containsKey(key)判断key是否存在： "+stringMap.containsKey("AU"));
        System.out.println("通过 containsValue(value) 判断value是否存在： "+stringMap.containsValue("阿根廷"));
        stringMap.replace("AR","阿根廷-测试替换方法");
        System.out.println("通过get(key)获取value:"+stringMap.get("AR"));

        //通过key 删除 value
        stringMap.remove("AR");

        System.out.println("-------------------------------");
        // 通过keySet()方法 获取map集合的所有key
        Set<String> keys = stringMap.keySet();
        for (String key:keys) {
            System.out.println("key:"+key+",value："+stringMap.get(key));
        }
        System.out.println("-------------------------------");
        Iterator<String> values = stringMap.values().iterator();
        while (values.hasNext()){
            System.out.println(values.next());
        }
        System.out.println("-------------------------------");
        Iterator<String> iteratorkeys =  stringMap.keySet().iterator();
        while (iteratorkeys.hasNext()){
            String key = iteratorkeys.next();
            System.out.println("key:"+key+",value："+stringMap.get(key));
        }
    }
}

练习3：

 代码实现：

import java.util.*;

public class LianXi {
    public static void main(String[] args) {
        Random random = new Random();
        List<Integer> list = new ArrayList<>();
//        System.out.println(random.nextInt(100)+1);
        int[] number = new int[10];
        for (int i = 0; i < 10; i++) {
            number[i] = random.nextInt(100)+1;
            if(number[i] > 10){
                list.add(number[i]);
            }
        }
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            Integer str = iterator.next();
            System.out.println(str);
        }

    }
}
import java.util.*;

public class Lianxi2 {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1,"张三丰");
        map.put(2,"周芷若");
        map.put(3,"汪峰");
        map.put(4,"灭绝师太");

        Iterator<Integer> iteratorkeys =  map.keySet().iterator();
        while (iteratorkeys.hasNext()) {
            Integer key = iteratorkeys.next();
            System.out.println("key:" + key + ",value：" + map.get(key));
        }

        map.put(5,"郭靖");

        map.remove(1);

        map.replace(2,"周林");
    }
}

叮咚叮咚~
关注
专栏目录
java数组排序
harborGao的博客
03-07 444
冒泡排序 冒泡排序是每个后端开发人员必须掌握的排序算法，也是最容易理解的排序算法。主要使用嵌套循环，假设数组长度为10，以从小到大排序为例，内层循环中，将相邻的元素进行比较，比较后将较大的数向后移(例如array[0]大于array[1],则交换二者的位置)，每执行完一次内层循环，则将最大的元素放到数组的末尾。则执行9(数组长度-1)次内层循环，则确定了9个数的位置，自然最后一个数的位置也确定了。...
java中的数组与集合的排序
Enjoy Life with Sun
11-29 3950
java中的数组与集合的排序两种需要排序的对象：数组和集合1、集合java.util.Collections类提供了排序方法sort();static voidsort(List list)           Sorts the specified list into ascending order, according to the natural ordering of its elemen
【Java】Java数组排序详解：全面掌握Arrays.sort()的几种用法
最新发布
科技改变人类，技术成就未来
07-22 1739
在 Java 开发中，java.util.Arrays 类提供了许多实用工具，用于操作数组。其中，Arrays.sort() 方法是对数组进行排序的常用方法。本文将详细介绍 Arrays.sort() 的不同用法，包括基本类型数组、对象数组、多维数组和自定义比较器的排序。
Java的数组排序
cd_sywe的博客
10-23 564
冒泡排序 对数组进行排序是程序中非常基本的需求。常用的排序算法有冒泡排序、插入排序和快速排序等。 我们来看一下如何使用冒泡排序算法对一个整型数组从小到大进行排序： import java.util.Arrays; public class Main { public static void main(String[] args) { int[] n = { 28, 12,...
java的数组排序
qq_44716544的博客
10-08 349
通过Arrays类的静态sort()方法可以实现对数组的排序。sort)方法提供了多种重载形式，可对任意类型的数组进行升序排序。 语法如下: Arrays.sort(object) 其中，object是指进行排序的数组名称。 案例： package test; import java.util.Arrays; public class Three { public static void main(String[] args) { // TODO 自动生成的方法存根 int a[..
java集合/数组排序
02-22 287
在平时开发的过程中，经常会遇到需要对数组、集合中元素按规则进行排序，本文记录在开发过程中可能遇到的情况以及相关的完整代码示例。 知识点 Comparable<>接口 实现了该接口的对象，必须实现compareTo方法，一个对象实现了该接口，说明该对象具有排序功能，比如String、Integer等。 Comparator<> 接口 要实现自定义排序器的时候，需要实现该...
java数组排序示例分享
09-04
Java 数组排序示例分享 Java 数组排序是Java编程中的一种常见操作，用于对数组中的元素进行排序。本文将详细介绍 Java 数组排序示例，包括代码实现和详细解释。 知识点1：Java 数组 在Java中，数组是一种数据结构...
java集合与数组的相同点和不同点
08-26
在Java编程语言中，数组和集合都是用于存储和管理数据的结构，但它们在功能、灵活性和使用场景上存在显著的差异。以下是关于Java集合与数组的相同点和不同点的详细说明： 相同点： 1. 容器：无论是数组还是集合，...
java对double数组排序示例分享
09-04
下面，我们将深入探讨Java对`double`数组排序的实现方法以及代码中的关键细节。 首先，让我们看一下提供的代码片段。这是一个简单的冒泡排序算法，用于对`double`数组进行升序排列。冒泡排序是一种基础排序算法，它...
数组和集合
05-25
在编程领域，尤其是Java语言中，数组和集合是处理数据的两种基本方式。数组（Array）是同类型数据的有序集合，而集合（Collection）则是更加灵活的数据结构，可以存储任意类型的对象。Java为这两种数据存储方式提供...
java 数组效率_Java数组和集合的效率问题
weixin_32233079的博客
02-12 695
本篇文章由柠檬学院研发部整理，独家原创，谢绝转载。Java经典入门教程：Java轻松入门经典教程​ke.qq.comJava构架师进阶：Java构架师技术栈/Java架构师/微服务/分布式/高并发/性能优化​ke.qq.com数组和集合的效率问题数组是JAVA语言内置的数据类型，它是一个线性的序列，所以它可以快速的访问其他的元素。但是速度是要有代价的，当你创建了一个数组之后，它的容量就固定了，而且...
JAVA数组排序
幻城砂的博客
03-16 66
JAVA 中数组的几种排序方法 标准的！
yehaiping1214的专栏
04-23 695
1、数组的冒泡排序 public void bubbleSort(int a[]) {     int n = a.length;     for (int i = 0; i  for (int j = 0; j      if (a[j] > a[j + 1]) {          int temp = a[j];   a[j] = a[j + 1];   a[j + 1] = temp;
Java数组排序
Aiden_Zhao的博客
07-17 2424
Comparable 是排序接口，若一个类实现了 Comparable 接口，就意味着该类“支持排序”或者“具有比较能力”。} // 重写compareTo方法 @Override public int compareTo(Dog dog) {return 1;return - 1;} return 0;} }返回正数，表示当前实例比传入的实例大返回复数，表示当前实例比传入的实例小返回0，表示两者相等。
Java自定义数组排序实现
在Java编程语言中，数组是一种基本的数据结构，用于存储同类型的元素集合。数组的排序是常见的操作，Java提供了多种内置的排序方法，如Arrays.sort()，但这些内置方法可能无法满足所有复杂的排序需求。因此，有时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值