我的Java学习笔记-集合篇

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量112 收藏
点赞数
分类专栏： Java进阶 文章标签： java 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44876636/article/details/115259955
版权

一、理论部分

1.集合的概念(Collection，Map)

一系列对象的集合，类似于数学上的集合{1，2，3}。
可以添加，删除，修改，查找，比较。
Collection继承了Iterable接口。

2.与数组的区别

数组的长度一旦设定就不可以修改
集合可以任意修改长度
(个人觉得数组与ArrayList集合的关系有点像String与StringBuffer的关系)

3.集合的分类

在这里插入图片描述

4.迭代器

迭代器模式：就是提供一种方法对一个容器对象中的各个元素进行访问，而又不暴露该对象容器的内部细节。
接口的定义：

package java.util;

public interface Iterator<E> {
    boolean hasNext();//判断是否存在下一个对象元素

    E next();//获取下一个元素

    void remove();//移除元素
}

使用1：Iterator iterator();

使用2：foreach循环

5.比较器

Comparable接口
public interface Comparable该接口对实现它的每个类的对象强加一个整体排序。
这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。
Collections.sort （和Arrays.sort ）可以自动对实现此接口的对象进行列表（和数组）排序。

只有一个方法：

public int compareTo(T o)将此对象与指定的对象进行比较以进行排序

Comparator接口
public interface Comparator比较功能，对一些对象的集合施加了一个整体排序 。
可以将比较器传递给排序方法（如Collections.sort或Arrays.sort ），以便对排序顺序进行精确控制。

常用方法解读
public int compare(T o1, T o2)比较其两个参数的顺序
public boolean equals(Object obj)指示某个其他对象是否等于此比较器

二、操作部分

1. List接口介绍

java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对
象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过
索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

常用方法解读
public void add(int index, E element)将指定的元素，添加到该集合中的指定位置上
public E get(int index)返回集合中指定位置的元素
public E remove(int index)移除列表中指定位置的元素, 返回的是被移除的元素
public E set(int index, E element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素

方法演示代码：

    public class TestList {
        public static void main(String[] args) {
			// 创建List集合对象
            List<String> list = new ArrayList<String>();
			// 往 尾部添加 指定元素
            list.add("图图");
            list.add("小美");
            list.add("不高兴");
            System.out.println(list);
			// add(int index,String s) 往指定位置添加
            list.add(1,"没头脑");
            System.out.println(list);
			// String remove(int index) 删除指定位置元素 返回被删除元素
			// 删除索引位置为2的元素
            System.out.println("删除索引位置为2的元素");
            System.out.println(list.remove(2));
            System.out.println(list);
			// String set(int index,String s)
			// 在指定位置 进行 元素替代（改）
			// 修改指定位置元素
            list.set(0, "三毛");
            System.out.println(list);
			// String get(int index) 获取指定位置元素
			// 跟size() 方法一起用 来 遍历的
            for(int i = 0;i<list.size();i++){
                System.out.println(list.get(i));
            }
			//还可以使用增强for
            for (String string : list) {
                System.out.println(string);
            }
            
        }
        
    }

ArrayList
java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为
查询数据、遍历数据，所以 ArrayList 是最常用的集合。

除继承自List外的常用方法解读
public boolean add(E e)将指定元素追加到此列表的末尾
public void clear()从列表中删除所有元素
public boolean contains(Object o)如果此列表包含指定的元素，则返回 true
public int indexOf(Object o)返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
public int size()返回此列表中的元素数
public Object[] toArray()以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

方法演示代码：

判断集合里是否存在一个 name等于 "hero 1"的对象

import java.util.ArrayList;
import charactor.Hero;

public class TestArryList {
    public static void main(String[] args) {
        ArrayList heros = new ArrayList();
  
        // 初始化5个对象
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i));
        }
        Hero specialHero = new Hero("special hero");
        heros.add(specialHero);
        String name = "hero 1";
        for (int i = 0; i < heros.size(); i++) {
            Hero h = (Hero) heros.get(i);
            if(name.equals(h.name ) ){
                System.out.printf("找到了name是%s的对象",name);
                break;
            }
        }
         
    }
  
}

LinkedList
java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。

除继承自List外的常用方法解读
public void addFirst(E e)将指定元素插入此列表的开头
public void addLast(E e)将指定元素添加到此列表的结尾
public E getFirst()返回此列表的第一个元素
public E getLast()返回此列表的最后一个元素
public E removeFirst()移除并返回此列表的第一个元素
public E removeLast()移除并返回此列表的最后一个元素
public E pop()从此列表所表示的堆栈处弹出一个元素
public void push(E e)将元素推入此列表所表示的堆栈
public boolean isEmpty()如果列表不包含元素，则返回true

方法演示代码：

二叉树的创建与中序遍历

import java.util.ArrayList;
import java.util.List;
 
public class Node {
    // 左子节点
    public Node leftNode;
    // 右子节点
    public Node rightNode;  
    // 值
    public Object value;
  
    // 插入 数据
    public void add(Object v) {
        // 如果当前节点没有值，就把数据放在当前节点上
        if (null == value)
            value = v;
  
        // 如果当前节点有值，就进行判断，新增的值与当前值的大小关系
        else {
            // 新增的值，比当前值小或者相同
             
            if ((Integer) v -((Integer)value) <= 0) {
                if (null == leftNode)
                    leftNode = new Node();
                leftNode.add(v);
            }
            // 新增的值，比当前值大
            else {
                if (null == rightNode)
                    rightNode = new Node();
                rightNode.add(v);
            }
  
        }
  
    }
  
 // 中序遍历所有的节点
    public List<Object> values() {
        List<Object> values = new ArrayList<>();
  
        // 左节点的遍历结果
        if (null != leftNode)
            values.addAll(leftNode.values());
  
        // 当前节点
        values.add(value);
  
        // 右节点的遍历结果
        if (null != rightNode)
  
            values.addAll(rightNode.values());
  
        return values;
    }
  
    public static void main(String[] args) {
  
        int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
  
        Node roots = new Node();
        for (int number : randoms) {
            roots.add(number);
        }
  
        System.out.println(roots.values());
  
    }
}

2.Set接口介绍

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。
与 List 接口不同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

常用方法与List接口的差不多

方法演示代码：

public class TestSet {

	public static void main(String[] args) {
		//创建 Set集合
		HashSet<String> set = new HashSet<String>();
		//添加元素
		set.add(new String("cba"));
		set.add("abc");
		set.add("bac");
		set.add("cba");
		//遍历
		for (String name : set) {
			System.out.println(name);
		}
	}
}

HashSet
java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。
HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。
保证元素唯一性的方式依赖于： hashCode 与 equals 方法。

除继承自List外的常用方法解读
public boolean add(E e)将指定元素追加到此列表的末尾
public void clear()从列表中删除所有元素
public boolean contains(Object o)如果此列表包含指定的元素，则返回 true
public int size()返回此列表中的元素数

方法演示代码：

创建一个长度是100的字符串数组，使用长度是2的随机字符填充该字符串数组，统计这个字符串数组里重复的字符串有多少种

public class TestHashSet {
    //随机字符串
    private static String randomString(int length) {
        String pool = "";
        for (short i = '0'; i <= '9'; i++) {
            pool += (char) i;
        }
        for (short i = 'a'; i <= 'z'; i++) {
            pool += (char) i;
        }
        for (short i = 'A'; i <= 'Z'; i++) {
            pool += (char) i;
        }
        char cs[] = new char[length];
        for (int i = 0; i < cs.length; i++) {
            int index = (int) (Math.random() * pool.length());
            cs[i] = pool.charAt(index);
        }
        String result = new String(cs);
        return result;
    }


    public static void main(String[] args) {
        //创建并初始化字符串数组
        String[] strings = new String[100];
        //Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < strings.length; i++) {
            //String str = scanner.next().substring(0,2);
            strings[i] = randomString(2);
        }
        //遍历字符串
        int k= 1;
        for (String s :
                strings) {
            System.out.print(s+"\t");
            if(k%10==0)
                System.out.println();
            k++;
        }
        //把重复的字符串放入HashSet中
        HashSet<String> hashSet = new HashSet<>();
        for (int i = 0; i < strings.length; i++) {
            int count = 0;
            for (int j = 1; j < strings.length; j++) {
                if(strings[j].equalsIgnoreCase(strings[i])){
                    count++;
                    if(count==2){
                        hashSet.add(strings[j]);
                        break;
                    }
                }
            }
        }
        //遍历HashSet
        int x = hashSet.size();
        System.out.println(x);
        for (String hs :
                hashSet) {
            System.out.println(hs);
        }

    }
}

TreeSet
java.util.TreeSet 是 Set 接口的一个实现类。
TreeSet集合底层数据结构采用红黑树实现，元素唯一且已经排好序。
默认情况下，TreeSet中的数据是从小到大排序的。

除继承自Set外的常用方法解读
public boolean add(E e)将指定元素追加到此列表的末尾
public void clear()从列表中删除所有元素
public boolean contains(Object o)如果此列表包含指定的元素，则返回 true
public int size()返回此列表中的元素数
public E ceiling(E e)返回此集合中最小元素大于或等于给定元素，如果没有此元素，则返回 null
public Comparator<? super E> comparator()返回用于对该集合中的元素进行排序的比较器，或null，如果此集合使用其元素的natural ordering
public E first()/last()返回此集合中当前的第一个（最低）元素/最后（最高）元素

代码如下（示例）：

public static void main(String[] args) {

        TreeSet<Integer> ts = new TreeSet<>();

        ts.add(33);
        ts.add(2);
        ts.add(11);
        ts.add(9);
		//元素没有下标，只能通过迭代器或者foreach循环遍历
        Iterator it = ts.iterator();
        while (it.hasNext()){
            System.out.println(it.next());//运行结果按从小到大的顺序输出
        }
    }

3.Map接口介绍

Map 中的集合，元素是成对存在的(键值对)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
Collection 中的集合称为单列集合， Map 中的集合称为双列集合。
Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

常用方法解读
public V put(K key, V value)把指定的键与指定的值添加到Map集合中
public V remove(Object key)把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
public V get(Object key)根据指定的键，在Map集合中获取对应的值。
public Set keySet()获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet()获取到Map集合中所有的键值对对象的集合(Set集合)

代码如下（示例）：

public class TestMap {
	public static void main(String[] args) {
		//创建 map对象
		Map<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("黄晓明", "杨颖");
		map.put("文章", "马伊琍");
		map.put("邓超", "孙俪");
		System.out.println(map);
		//删除键为"邓超"对应的键值对
		System.out.println(map.remove("邓超"));
		System.out.println(map);
		// 想要查看 黄晓明的媳妇 是谁
		System.out.println(map.get("黄晓明"));
		System.out.println(map.get("邓超"));//输出null
	}
}

HashMap
java.util.HashMap<K,V> 是Map接口的一个实现类。

除继承自Map外的常用方法解读
public void clear()从这张地图中删除所有的映射
public boolean containsKey(Object key)如果此映射包含指定键的映射，则返回 true
public boolean containsValue(Object value)如果此地图将一个或多个键映射到指定值，则返回 true
public int size()返回此地图中键值映射的数量

代码如下（示例）：

HashMap键与值的翻转

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class TestHashMap {
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new HashMap<>();
        hashMap.put("adc","物理英雄");
        hashMap.put("apc","魔法英雄");
        hashMap.put("t","坦克");

        List<String> listKey = new ArrayList<>(hashMap.keySet());
        List<String> listValues = new ArrayList<>(hashMap.values());

        HashMap<String,String> hashMap1 = new HashMap<>();
        hashMap1.put(listValues.get(0),listKey.get(0));
        hashMap1.put(listValues.get(1),listKey.get(1));
        hashMap1.put(listValues.get(2),listKey.get(2));

        System.out.println(hashMap1);
    }
}

TreeMap
java.util.TreeMap<K,V> 是Map接口的一个实现类。
是一个有序的key-value集合，基于红黑树的 NavigableMap实现。
该映射根据其键的大小顺序进行排序，或者根据创建映射时提供的 Comparator进行排序。

构造方法

我懒得做个表了，凑合一下吧！
在这里插入图片描述

除继承自Map外的常用方法解读
public void clear()从这张地图中删除所有的映射
public boolean containsKey(Object key)如果此映射包含指定键的映射，则返回 true
public boolean containsValue(Object value)如果此地图将一个或多个键映射到指定值，则返回 true
public int size()返回此地图中键值映射的数量
public Comparator<? super K> comparator()返回用于订购此地图中的键的比较器，或null如果此地图使用其键的natural ordering
public V replace(K key, V value)只有当目标映射到某个值时，才能替换指定键的条目
public Set<Map.Entry<K,V>> entrySet()返回此地图中包含的映射的Set视图

代码如下（示例）：

输出为：
在这里插入图片描述

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

public class TestTreeMap {
    public static void main(String[] args) {
        TreeMap<String,Integer> map = new TreeMap<>();

        String key = null;
        Integer integ = null;
        for (int i = 0; i < 5; i++) {
            map.put("Z"+i+"z",i*10);
        }
        map.put("X",-2);
        map.put("y",5);
        Iterator iter = map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry entry = (Map.Entry)iter.next();
            // 获取key
            key = (String)entry.getKey();
            // 获取value
            integ = (Integer)entry.getValue();
            System.out.println("[key - "+key+"]  [value - "+integ+"]");
        }
    }
}

总结

集合是一个很好用的容器！

a，继续加油吧!

白色菩提
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java学习笔记-java思维导图流程图表格整理
11-19
Java是一种广泛使用的面向对象...这些只是Java编程中的基础概念，随着学习深入，还会涉及到异常处理、集合框架、IO流、多线程、网络编程、数据库连接等内容。理解并熟练掌握这些知识点，将为Java程序员打下坚实的基础。
一文了解Python面向对象
Jock2018的博客
05-08 960
本文将主要介绍 Python 面向对象，包括类定义、各类属性、各类方法、继承、多态、封装、单例模式等。阅读本文预计需要 30 min 一文了解Python面向对象1. 前言2. 面向对象 VS 面向过程3. 初窥类3.1 类的定义3.2 类对象和实例对象4. 属性4.1 类属性和实例属性4.2 公有属性、半私有属性和私有属性4.3 魔法属性4.3.1 `__slots__` 魔法属性5. 方法...
JAVA--集合框架--List get() 和 equals()方法
qq_35486871的博客
05-11 8034
//如果就是要判断集合里是否存在一个 name等于 "hero 1"的对象.判断一个ArrayList()中的对象是否有名字是“hero 1”的。思路：创建ArrayList对象heros.        Hero h = heros.get(i);package 集合框架; import java.util.*; //如果就是要判断集合里是否存在一个 name等于 "hero 1"的对象，应该怎...
关于List 的get方法
兔子临死前的专栏
05-02 1万+
看下面一段程序 List list = new ArrayList(); System.out.println(list.get(0)); 这个会输出什么？ ------------------------------ Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
JAVA中级之集合框架
ysl的博客
10-22 369
使用数组的局限性 如果要存放多个对象，可以使用数组，但是数组有局限性 比如 声明长度是10的数组 不用的数组就浪费了 超过10的个数，又放不下 package collection; public class TestCollection { public static void main(String[] args) { //数组的局限性 Her...
list.get(0) 和list.get(i)的区别
热门推荐
Architect_CSDN的博客
03-23 4万+
List&lt;People&gt;list=newArrayList&lt;People&gt;();for(inti=0;i&lt;list.size();i++){Peoplepeople=list.get(i);}//当i=0时，取得是list集合中第一个元素，//当i=1时，取得是list集合中第二个元素，......//当i=i时，取得是list集合中第i+1...
Java集合学习笔记.pdf
11-28
Java集合学习笔记.pdf
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
集合-黑马程序员Java学习笔记
07-24
总的来说，这份黑马程序员的Java学习笔记将带你深入理解Java集合框架，掌握如何根据需求选择合适的集合类型，以及高效地操作和管理对象。通过实践和理论的结合，你将能够熟练地运用这些知识解决实际编程问题。
《java学习》-Java 学习笔记.zip
04-02
本压缩包文件“《java学习》-Java 学习笔记.zip”包含了丰富的学习资源，帮助初学者和进阶者深入理解Java编程。 1. **Java基础知识** - **语法**：Java的基础语法包括变量、数据类型、运算符、流程控制语句（如if-...
集合框架常用方法
追梦的女孩博客
12-03 277
学习一下集合框架的常用方法吧 增加 add有两种用法 第一种是直接add对象，把对象加在最后面 heros.add(new Hero("hero " + i)); 第二种是在指定位置加对象 heros.add(3, specialHero); 自己练习，犯了错误。 代码如下 public class TestCollection { public static void main(String[] args) { ArrayList h=new ArrayList();
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 454
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 261
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 625
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 372
集合之Map
【Java算法专场】二分查找(下）
zhyhgx的博客
07-27 862
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 744
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 420
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java学习笔记：面向对象与集合框架详解
在Java学习笔记中，首先介绍了面向对象的基础，包括集合框架和Oracle数据库编程。集合框架是Java中处理对象集合的重要工具，包括ArrayList、LinkedList、HashMap等数据结构。Oracle编程部分则强调了Oracle数据库的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值