浅学 “ Java常见STL ”

已于 2022-04-10 16:01:12 修改
阅读量2.9k 收藏 23
点赞数 3
分类专栏： Java 文章标签： java
于 2022-04-03 16:15:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Piink/article/details/123939405
版权

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

Collection集合常用功能

 public static void main(String[] args){
         Collection<String> coll=new ArrayList<>();
         //向集合中添加元素
         coll.add("hello");
         coll.add("zhong");
         coll.add("guo");
         System.out.println(coll);
         //删除集合中的某个元素
         boolean r=coll.remove("hello");
         System.out.println(coll);

         //清空集合
         coll.clear();
         System.out.println(coll);
        //判断集合中是否包含某个元素
        boolean f=coll.contains("guo");
        System.out.println(f);
        
        //判断集合是否为空
        System.out.println(coll.isEmpty());
        
        //获取集合的长度
        System.out.println(coll.size());
        
        //将集合转成一个数组
        Object[] arr = coll.toArray();
        for(int i=0;i<arr.length;i++)
            System.out.println(arr[i]);
    }

Iterator迭代器

Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同

Collection接口与Map接口主要用于存储元素，而Iterator主要用于 迭代访问(即遍历) Collection中的元素，因此Iterator对象也被称为迭代器

那么迭代是什么意思？

即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出来，一直把集合中的所有元素全部取出

Iterator接口

在这里插入图片描述

public static void main(String[] args){
        Collection<String> coll= new ArrayList<>();
        coll.add("AAA");
        coll.add("BBB");
        coll.add("CCC");
        coll.add("DDD");
        coll.add("EEE");
        coll.add("FFF");
        Iterator<String> it=coll.iterator();
        //判断还有没有下一个元素，有则返回true

        //boolean b=it.hasNext();
        //System.out.println(b);//true

        //String s =it.next();
        //System.out.println(s);//AAA

        //boolean b1=it.hasNext();
        //System.out.println(b1);//true

        //String s1 =it.next();
        //System.out.println(s1);//BBB
        //上面的输出方法太麻烦了，

        //循环结束的条件是：hasNext方法返回false
        
        //迭代方法遍历  
        
        while(it.hasNext())
        {
            String e=it.next();
            System.out.println(e);
        }
        
        //for循环遍历
        
        for(Iterator<String> it2=coll.iterator();it2.hasNext();){
            String e=it2.next();
            System.out.println(e);
        }
    }

LinkedList集合

在这里插入图片描述

Set集合存储元素不重复的原理

在这里插入图片描述

HashSet存储自定义类型元素

   //实现同名同年龄的人只能存储一次
        //必须重写hashCode方法和equals方法
    public static void main(String[] args){
        //创建HashSet集合存储person
        HashSet<person> s=new HashSet<>();

        person p=new person("张三",18);
        person p1=new person("张三",18);
        person p2=new person("王五",22);

        System.out.println(p.hashCode());//764977973
        System.out.println(p1.hashCode());//381259350
        System.out.println(p1==p);//false 哈希值不同

        System.out.println(p.equals(p1));//false

        s.add(p);
        s.add(p1);
        s.add(p2);
        System.out.println(s);
    }

public class person extends Object{
  private String name;
  private int age;

    public person() {

    }

    public person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //添加下面这段代码，重写hashCode方法和equals方法
 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        person person = (person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }

LinkedHashSet集合

/*
        LinkedHashSet集合extends HashSet集合
        LinkedHashSet集合特点：
        底层是一个哈希表(数组+链表/红黑树)+链表：多了一条链表(记录元素的存储顺序)，保证元素有序
    */

    public static void main(String[] args){
        //创建HashSet集合存储person
        HashSet<String> s=new HashSet<>();

        s.add("abc");
        s.add("abc");
        s.add("hello");
        s.add("world");
        System.out.println(s);//[abc, world, hello] 无序 不允许重复

        LinkedHashSet<String> s1=new LinkedHashSet<>();

        s1.add("abc");
        s1.add("abc");
        s1.add("hello");
        s1.add("world");
        System.out.println(s1);//[abc, hello, world]有序 不允许重复

可变参数

  /*
       可变参数
       使用前提
           当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
       使用格式
           修饰符 返回值类型 方法名（数据类型...变量名）{}
       可变参数的原理：
           底层是一个数组，根据传递参数个数不同，创建不同长度的数组，传递的参数可以是任意个
       注意
          一个方法的参数列表只能有一个可变参数
          如果方法的参数有多个，那么可变参数必须写在参数列表的末尾
    */
    public static void main(String[] args) {
       int i=add(1,2,3,4,5,6,7,8,9,10);
        System.out.println(i);

    }
    public static int add(int...arr){
        int ans=0;
        for(int i:arr)
        {
          ans+=i;
        }
        return ans;
    }
    //可变参数的终极写法，可以传入任意类型的参数
    public static void method(Object...obj){

    }

Collections集合常用功能

注意这个是Collections(+s的哦)，和前面的是不一样的
在这里插入图片描述

/*
    Comparator和Comparable的区别
    Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
    Comparator：相当于找一个第三方裁判，比较两个
    */
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
       /* list.add("a");
        list.add("b");
        list.add("c");
        System.out.println(list);//[a, b, c]
        */
        //如果需要存大量数据
        Collections.addAll(list,"a","b","c");
        System.out.println(list);//[a, b, c]
        //打乱集合顺序Integer
        Collections.shuffle(list);
        System.out.println(list);//[c, b, a]

        ArrayList<Integer> list1 = new ArrayList<>();
        Collections.addAll(list1,1,5,6,2,4,7,8,9);
        //默认是从小到大
        Collections.sort(list1);
        System.out.println(list1);//[1, 2, 4, 5, 6, 7, 8, 9]
        //
        ArrayList<person> list2 = new ArrayList<>();
        list2.add(new person("张三",21));
        list2.add(new person("李四",20));
        list2.add(new person("王五",19));

        System.out.println(list2);
        //sort使用前提
        //该排序的集合里面存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则
        //Comparable排序
        //return this.getAge()-o.getAge();//年龄从小到大
        //return o.getAge()-this.getAge();//年龄从大到小
        Collections.sort(list2);
        System.out.println(list2);

        ArrayList<Integer> list3 = new ArrayList<>();
        list3.add(3);
        list3.add(4);
        list3.add(1);
        list3.add(2);
        System.out.println(list3);

        Collections.sort(list3, new Comparator<Integer>() {
            //重写比较的规则
            @Override
            public int compare(Integer t1, Integer t2) {
               // return 0;
               // return t1-t2;//升序
                return t2-t1;//降序
            }
        });
        System.out.println(list3);
    }

public class person implements Comparable<person>{
  private String name;
  private int age;

    public person() {

    }

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //重写排序的规则
    @Override
    public int compareTo(person o) {
        //return 0;
        //return this.getAge()-o.getAge();//年龄从小到大
        return o.getAge()-this.getAge();//年龄从大到小
    }
}

Map集合

Map<K,V> ，k-此映射所维护的键的类型 ，v-映射值的类型

一个映射不能包含重复的键，每个键最多只能映射到一个值

Map集合的特点：
1.Map集合是一个双列集合，一个元素包含两个值(一个key，一个value)
2.Map集合中的元素，key与value的数据类型可以相同，也可以不同
3.Map集合中的元素，key不允许重复，value可以重复
4.Map集合中的元素，key与value一一对应

在这里插入图片描述

HashMap特点：

  1. HashMap底层是哈希表，查询速度快
    jdk1.8前，数组+单向链表
    jdk1.8后，数组+单向链表/红黑树（链表长度超过8变为红黑树）
    2.HahsMap集合是一个无序的集合，存储元素和取出元素的顺序可能不一致

LinkedMap特点：

1.LinkedHashMap集合底层是哈希表+链表

2.LinkedHashMap集合是一个有序的结合，存储元素和取出元素的顺序一致

在这里插入图片描述

public static void main(String[] args) {
        demo01();//put:把指定的键与指定的值添加到Map集合中
        demo02();//remove:把指定的键所对应的键值对元素在map集合中删除
        demo03();//containsKey:判断结合中是否包含指定的键
        demo04();//get:根据指定的键，在map集合中获取对应的值
    }
    public static void demo01(){

        //put操作

        Map<String,String> map=new HashMap<>();
        //存储键值对的时候，key不重复，返回值v是null
        //存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value值
        String str = map.put("张三", "李四");
        System.out.println(str);//null

        String str1 = map.put("张三", "李四123");
        System.out.println(str1);//李四

        System.out.println(map);//{张三=李四123}

        map.put("王五","赵六");
        map.put("a","c");
        map.put("b","c");
        System.out.println(map);//{a=c, 张三=李四123, b=c, 王五=赵六}
    }
    public static void demo02(){

        //remove操作

        //key存在，v返回被删除的值
        //key不存在，v返回null;
        Map<String,Integer> map=new HashMap<>();
        map.put("x",1);
        map.put("y",2);
        map.put("z",3);
        Integer x1 = map.remove("x");
        System.out.println(x1);//1

        Integer x2 = map.remove("a");
        System.out.println(x2);//null

        System.out.println(map);//{y=2, z=3}
    }
    public static void demo03(){

        //containsKey操作

        //key存在，返回true
        //key不存在，返回false;
        Map<String,Integer> map=new HashMap<>();
        map.put("x",1);
        map.put("y",2);
        map.put("z",3);
        boolean y1=map.containsKey("x");
        System.out.println(y1);//true

        boolean y2=map.containsKey("a");
        System.out.println(y2);//false
    }
   
 public static void demo04(){

        //get操作

        //key存在，返回v
        //key不存在，返回null;
        Map<String,Integer> map=new HashMap<>();
        map.put("x",1);
        map.put("y",2);
        map.put("z",3);

        Integer z1=map.get("x");
        System.out.println(z1);//1

        Integer z2=map.get("a");
        System.out.println(z2);//null
    }

Map集合的遍历方式


//keyset用法

public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("x",1);
        map.put("y",2);
        map.put("z",3);
        Set<String> set= map.keySet();
        //使用迭代器
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
              String key=it.next();
              Integer value=map.get(key);
            System.out.println(key+"="+value);
        }
        //使用增强for
        for(String key:set){
            Integer value=map.get(key);
            System.out.println(key+"="+value);
        }
        //增强for简化版
        for(String key:map.keySet()){
            Integer value=map.get(key);
            System.out.println(key+"="+value);
        }
    }


//EntrySet用法

  /*
 Map集合的第二种遍历方式：使用Entry对象遍历
 Map集合中的方法：
        set<Map.Entry<K,V>> entryset() 返回此映射中包含的键的set视图
 实现步骤：
       1.使用Map集合的方法entryset(),把Map集合多个yEntr取出来，存储到一个set集合中
       2.遍历set集合，获取每一个Entry对象
       3.使用Entry对象中的方法getkey()和getValue()获取键与值
 */
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("x",1);
        map.put("y",2);
        map.put("z",3);

        Set<Map.Entry<String, Integer>> set = map.entrySet();
       // Set<String> set= map.keySet();
        //使用迭代器
        Iterator<Map.Entry<String,Integer>> it = set.iterator();
        while(it.hasNext()){
            Map.Entry<String, Integer> nx = it.next();
            String key = nx.getKey();
            Integer value = nx.getValue();
            System.out.println(key+"="+value);
        }
        //使用增强for
       for(Map.Entry<String,Integer> entry:set){
           String key = entry.getKey();
           Integer value = entry.getValue();
           System.out.println(key+"="+value);
        }
    }

Hashtable集合

    /*
    Hashtable ：底层是哈希表，不能存储null值，null键
    */
    public static void main(String[] args) {
      HashMap<String,String> mp=new HashMap<>();
      mp.put(null,"a");// 这种情况存储不进去但不会报错
      mp.put("b",null);
      mp.put(null,null);
      System.out.println(mp);

        Hashtable<String,String> table=new Hashtable<>();
        table.put("1","a");
        table.put("b","2");
       // table.put(null,null);//这种情况会报错
        System.out.println(table);
    }

JDK9对集合添加元素的优化—of方法

    /*
    list接口、Set接口、Map接口，里面增加了一个静态的方法of，可以给集合一次性添加多个元素
    使用前提：
        当集合中存储的元素的个数已经确定了，不在改变时使用
     注意：
        of方法只适用于list接口、set接口、Map接口，不适用于接接口的实现类
        of方法的返回值是一个不能改变的集合，集合不能在使用add，put方法添加元素，会抛出异常
        set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛出异常
    */
    public static void main(String[] args) {
        List<String> a = List.of("a", "b", "c");
        System.out.println(a);

        //Set<String> b = Set.of("1","1" ,"2", "3");//错误，不可重复
        Set<String> b = Set.of("1" ,"2", "3");
        System.out.println(b);

        //Map<String, String> x = Map.of("x", "1", "y", "2","x","3");//x重复
        Map<String, String> x = Map.of("x", "1", "y", "2");
        System.out.println(x);
    }
Piink
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
xml浅学笔记
05-15
1、XML AJAX: Asynchronous Javascript And Xml 1、什么是XML eXtensible Markup Language 可扩展的 标记 语言 XML的标记没有预定义过，需要自行定义 XML的宗旨是做数据传递的，而非数据显示 ...
浅学二极管与三极管
06-24
二极管，三极管，PN接
Java STL容器
qq_34704689的博客
01-10 1646
HashMap的初始化大小是16，每次扩容，容量会变为之前的2倍。因此HashMap总是使用 2 的幂作为哈希表的大小。JDK1.8之前的版本多线程环境下扩容可能存在死循环和数据丢失的问题。【当一个桶位中有多个元素需要扩容时，多个线程同时对链表进行操作，头插法可能导致链表中的节点指向错误的位置，从而形成一个环形链表，进而使得查询元素的操作陷入死循环而无法结束】JDK1.8 版本HashMap 采用了尾插法。
Java C++常用STL容器归纳总结
最新发布
qq_53165278的博客
05-11 970
在实际编程中，选择合适的容器取决于具体的需求和场景。LinkedList是一个双向链表实现，它提供了额外的插入和删除操作，但随机访问性能不如ArrayList。HashMap是基于哈希表的Map接口的实现，它提供了所有可选的映射操作，并允许使用null值和null键。HashSet是一个不包含重复元素的集合，它基于HashMap实现，因此它不允许包含重复的元素。是非常有用的数据结构，它们在解决各种算法问题时提供了不同的视角和操作方式。是一个先进先出（FIFO）的数据结构，它通过接口来实现，常用的实现类有。
【理论知识】浅析HashMap底层原理
m0_64210833的博客
03-28 2763
HashMap底层是基于数组+链表+红黑树。 默认初始容量为（数组长度为16），默认负载系数为0.75（这个表示的意思是扩容机制当容量达到75%的时候自动进行扩容，当扩容的时候，会创建新的数组，以前存放的数组将会重新通过hashCode进行排序，类似于hashCode/16取余得到下标存放在对应的数组中，扩容后hashCode/32.）。..................
Java中的STL
qq_52115728的博客
11-07 505
import java.math.*; import java.io.*; import java.math.*; import java.util.Scanner; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.Comparator; import java.util.Iterator; import java.util.Comparator; public
java stl容器_STL（“容器”集合）讲解
weixin_35906864的博客
02-17 514
2.2迭代器迭代器(iterator)是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口，所谓迭代器是一种概念上的抽象：那些行为上像迭代器的东西都可以叫做迭代器。然而迭代器有很多不同的能力，它可以把抽象容器和通用算法有机的统一起来。说到迭代器，咋们再往深研究一下，迭代器从作用上来说是最基本的部分。不过，在研究迭代器之前，我们...
浅学RC充放电电路
06-24
浅学RC充放电电路
浅学电子幸运大转盘知识
06-25
浅学电子幸运大转盘知识
pascal语言的浅学
04-21
Pascal是一种结构化编程语言，它的设计目标是提高代码的清晰性和可读性。这篇文章将带你初步了解Pascal语言的一些核心概念。 首先，Pascal的语法基础包括标记（TOKEN）。标记是构成程序的基本元素，包括特别符号、...
Java读取ASCII-STL
08-15
用Java读取ASCII形式的STL文件，结合JOpengl进行显示即可。
java实现点数据生成stl模型文件
qq_44645871的博客
03-08 325
java实现点数据生成vtk文件
JAVA-STL
超级氯化钾的博客
05-06 197
1. Vector C++ vector<int> vec; vec.push_back(1); //添加 vec.pop_back(); //删除数组最后的那个值 vec.size(); vec.clear(); //清空所有元素 ------------------------------------------- vec.front(); vec.back(); vec.empty(); //是否为空 -----------------------------------------
java常见STL
qq_42794545的博客
03-06 3602
Table of Contents 算法竞赛中的JAVA使用笔记输入与输出基本输入输入挂输出控制台输入输出重定向到文件大整数与高精度大整数BigInteger高精度BigDecimal字符串与进制转换字符串基本操作进制转换排序默认排序实现Comparator接口自定义比较器对自定义类的排序用lambda自定义比较器(仅 JAVA8 以上支持)C++STL中部分数据结构在JAVA中对应的用法s...
java入门：STL
cyhbyw的专栏
04-23 3399
List mylist1 = new ArrayList(); List mylist2 = new LinkedList(); List mylist3 = new Vector(); Vector vec = new Vector(); Queue  que = new LinkedList(); Stack  sta = new Stack();
算法竞赛中的JAVA使用笔记
hnshhslsh的专栏
11-14 4222
输入与输出 基本输入 输入挂 输出 控制台输入输出重定向到文件 大整数与高精度 大整数BigInteger 高精度BigDecima 字符串与进制转换 字符串基本操作 进制转换 排序 默认排序 实现Comparator接口自定义比较器 用lambda自定义比较器仅 JAVA8 以上支持 CSTL中部分数据结构在JAVA中的用法
qt 中的容器遍历
yjzl1911的专栏
01-20 6919
上一节我们大致了解了有关存储容器的相关内容。对于所有的容器，最常用的操作就是遍历。本章我们将详细了解有关遍历器的内容。 尽管这个问题不是本章需要考虑的，但是我们还是需要来解释下，为什么要有遍历器。没有遍历器时，如果我们需要向外界提供一个列表，我们通常会将其返回： 1234QListi
三十分钟掌握STL
10-14 2348
这是本小人书。原名是《using stl》，不知道是谁写的。不过我倒觉得很有趣，所以化了两个晚上把它翻译出来。我没有对翻译出来的内容校验过。如果你没法在三十分钟内觉得有所收获，那么赶紧扔了它。文中我省略了很多东西。心疼那，浪费我两个晚上。 译者：karycontact:karymay@163.netSTL概述STL的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使
静态方法中使用jdbctemplate_JdbcTemplate浅学
06-13
可以在静态方法中使用JdbcTemplate，只需在方法中创建JdbcTemplate对象即可。以下是一个简单的示例： ```java import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.DriverManagerDataSource; public class MyDao { private static JdbcTemplate jdbcTemplate; static { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/mydb"); dataSource.setUsername("username"); dataSource.setPassword("password"); jdbcTemplate = new JdbcTemplate(dataSource); } public static void myStaticMethod() { String sql = "SELECT COUNT(*) FROM mytable"; int count = jdbcTemplate.queryForObject(sql, Integer.class); System.out.println("Count: " + count); } } ``` 在上面的示例中，我们首先在静态块中创建了一个JdbcTemplate实例，然后在静态方法中使用该实例执行SQL查询。需要注意的是，我们在静态方法中不能直接访问非静态的实例变量或方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值