java集合框架

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量180 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25518825/article/details/125054743
版权

一、集合

(1):集合:

  • 集合就是由若干个确定的元素所构成的整体，存储对象的容器，可以存储任意数量、任意类型。

  • 为了方便统一处理一组类似或相同类型的数据。

  • 持有java对象，并对外提供访问接口。

(2):满足的目标:

  • 该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。

  • 该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。

  • 对一个集合的扩展和适应必须是简单的。

(3):集合与数组的区别:

  • 数组初始化后大小不可变；只能按照索引顺序存取。

  • 集合存储的长度是可变的；只能存储对象。

二、Collection接口

List接口

  • List{ArrayList,LinkedList}; 存储有序 不唯一的集合元素。

  • ArrayList:数组形式 连续的存储空间 查询速度快 增删速度慢。

  • LinkedList:双向链表 不连续的存储空间 增删速度快 查询速度慢。

ArrayList和LinkedList和Vactor的区别

区别ArrayListLinkedListVactor
实现的接口不同没有实现Queue,Deque接口，不支持队列操作实现了Queue和Deque接口，支持栈操作和队列操作没有实现Queue,Deque接口，不支持队列操作
内部实现不同内部采用数组存储元素采用双向链表来存储元素内部采用数组存储元素
删除效率不同删除慢删除快删除慢
是否支持随机访问随机访问效率高低随机访问效率高
线程安全非线程安全，适用与单线程环境非线程安全，适用于多线程安全线程安全，适用于多线程环境
扩容方式不同倍数增长固定增量不必进行扩容
package com.Demo;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
public class ArrayListTest {
    public static void main(String[] args) {
        //ArrayList<String> A_list=new ArrayList<String>();
        //接口不能实例化 只能通过子类
        List<String> list=new ArrayList<String>();
        //添加数据
        list.add("lmy");
        list.add("zs");
        list.add("ls");
        System.out.println(list);
        System.out.println(list.get(0));//获取下标索引的名字的值
        System.out.println("list.size():"+list.size());//获取集合中有多少元素
        System.out.println(list.remove(1));//删除指定的索引值 并返回此值
        System.out.println("list.size():"+list.size());//获取集合中有多少元素
        //判断是否存在指定的元素
        System.out.println("list.contains('zs'):"+list.contains("zs"));
​
        //set 按照参数内容替换指定索引处的值
        System.out.println("-------set()---------");
        System.out.println(list.get(1));
        System.out.println(list.set(1,"zs"));
        System.out.println(list.get(1));
​
        //indexOf 指定元素在集合中出现的位置
        System.out.println("-------indexOf()------");
        System.out.println(list);
        System.out.println("list.indexOf:"+list.indexOf("lmy"));
        System.out.println("list.lastIndexOf:"+list.lastIndexOf("lmy"));
        //集合中是否为空
        System.out.println("list.isEmpty():"+list.isEmpty());
        //toArray 转换为数组
       /* Object[] strArray = list.toArray();
        for (Object str : strArray) {
            System.out.println("str==="+str);
        }*/
​
        String[] strArray = list.toArray(new String[0]);
        for (String s : strArray) {
            System.out.println(s);
        }
​
        //清除集合中的元素
        list.clear();
        System.out.println(list.isEmpty());
​
​
        list.add("lmy");
        list.add("zs");
        list.add("ls");
        list.add("ww");
        System.out.println(list);
        //获取集合中所有的元素内容 --->遍历集合
        //1:普通的for循环
        System.out.println("第一种for循环========");
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }
        //2:使用foreach循环 （加强for循环）
        System.out.println("第二种foreach循环========");
        for (String str : list) {
            System.out.println(str);
        }
        //3:使用迭代器  对于集合遍历统一处理的一种方式
        System.out.println("第三种iterator循环========");
        Iterator<String> iterator = list.iterator();
        //iterator.hasNext() 判断是否还有元素
        //iterator.next()  返回下一个元素
        //iterator.remove()  删除
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
​
    }
}
​
package com.Demo;
​
import java.util.Iterator;
import java.util.LinkedList;
​
public class LinkedListTest {
    public static void main(String[] args) {
​
        LinkedList<String> list=new LinkedList<String>();
        list.add("刘梦园");
        list.add("张三");
        list.add("李四");
        System.out.println("原本的集合结果:"+list);
​
        list.addFirst("张三");
        System.out.println("addFirst的集合结果:"+list);
​
        list.addLast("木子李");
        System.out.println("addLast的集合结果:"+list);
​
        //list.getFirst()
        System.out.println("list.getFirst():"+list.getFirst());
        //list.getLast()
        System.out.println("list.getLast():"+list.getLast());
​
        System.out.println("删除之前的数据结果:"+list);
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        System.out.println("删除之后的数据结果:"+list);
​
        //for
        System.out.println("第一种for循环========");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
​
        System.out.println("第二种foreach循环========");
        for (String str : list) {
            System.out.println(str);
        }
​
        //3:使用迭代器  对于集合遍历统一处理的一种方式
        System.out.println("第三种iterator循环========");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
 

Set接口
 

  •  
    Set{HashSet,TreeSet}; 存储是无序的 唯一的集合元素 允许有null值
     
  •  
    实现Set接口的集合有：EnumSet、HashSet、TreeSet.
     
  
    •  
      EnumSet 枚举专用的Set，所有元素都是枚举类型。
       
    •  
      HashSet 底层是哈希表，线程不同步，无序，高效。HashSet堪称查询最快的集合，因为其内部是以HashCode实现的。它内部的顺序有哈希码来决定，所以不保证Set的迭代顺序。
       
    •  
      LinkedHashSet 有序 ,HashSet的子类。LinkedHashSet 不允许集合元素重复。
       
    •  
      TreeSet 底层是二叉树， 线程不同步。 基于TreeMap,生成一个总是处于排序状态的Set，内部以TreeMap来实现，利用元素的自然顺序对元素进行排序，或者根据创建时提供的Comparator进行排序。TreeSet底层使用红黑树结构存储数据，非线程安全的。
       
 

package com.Demo;
​
import java.util.HashSet;
import java.util.Iterator;
​
public class HashSetTest {
    public static void main(String[] args) {
        //重复数据的筛选
        HashSet<String> set=new HashSet<String>();
        set.add("刘梦园");
        set.add("张三");
        set.add("李四");
        set.add("李四");
        System.out.println(set);
        System.out.println("remove之前的结果条数:"+set.size());
        System.out.println(set.remove("刘梦园"));
        System.out.println("remove之后的结果条数:"+set.size());
​
        //遍历集合
        System.out.println("第一种foreach循环========");
        for (String str : set) {
            System.out.println(str);
        }
        System.out.println("第二种iterator循环========");
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
 

 

Set和List的区别
 

  •  
    Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
     
  •  
    Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
     
  •  
    List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。
     
 

三、Map
 

Map 接口存储一组键值对象，提供key（键）到value（值）的映射。不能存在相同的 Key，实现Map的有：HashMap、TreeMap、HashTable、Properties、EnumMap . Map要保证键的唯一性。
 

  •  
    HashTable 底层哈希表，线程同步，不能存在Null键，Null值。线程同步，以哈希表的数据结构实现，解决冲突时与HashMap一样也是采用散列表的形式，不过性能比HashMap要低。
     
  •  
    HashMap 底层哈希表，线程不同步，不能存在Null键，Null值。 以哈希表数据结构实现，查找对象时通过hash值计算其位置，它是为快速查询而设计的，内部定义了一个Hash表数组(Entry[] table),元素会通过hash转化函数转为在数组中的索引，如果有冲突的，则用散列链表的形式串起来。
     
  •  
    LinkedHashMap Map接口的哈希表和链接列表实现，具有预知的迭代顺序。
     
  •  
    TreeMap 底层二叉树，可以对Map集合中的键进行制定顺序的排序。键以某种排序规则排序，内部以Red-balck(红-黑树)数据结构实现。实现了SortedMap接口。
     
 

package com.Demo;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
​
public class HashMapTest {
    public static void main(String[] args) {
        HashMap<String,String> map=new HashMap<String,String>();
        //存储值put
        map.put("name","刘梦园");
        //获取值get
        System.out.println(map.get("name"));
        //删除值remove
        System.out.println(map.remove("name"));
        System.out.println("删除之后的值:"+map.get("name"));
​
        map.put("name","刘梦园");
        map.put("sex","女");
        map.put("address","许昌");
        map.put("phone","298392423");
        //遍历HashMap中所有的内容key value
        //1:Key Value 作为一个整体
        System.out.println("第一种 key value 全部的值================");
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<String, String> next = it.next();
            String key=next.getKey();
            String value=next.getValue();
            System.out.println(key+":"+value);
        }
​
        System.out.println("第二种 key的值================");
        Iterator<String> it2 = map.keySet().iterator();
        while (it2.hasNext()){
            String key = it2.next();
            String value=map.get(key);
            System.out.println(key+":"+value);
        }
​
        System.out.println("第三种 value的值================");
        Iterator<String> it3 = map.values().iterator();
        while (it3.hasNext()){
            String value = it3.next();
            System.out.println("value:"+value);
        }
    }
}
 

四、Collections类常用方法总结
 

sort
 

对集合进行排序
 

小结：
 

  •  
    String本身含有compareTo方法，可以直接调用sort方法，按自然顺序排序
     
  •  
    compareTo方法使用，升序排序(参数左比右)，降序排序(参数右比左)；另外compareTo方法里面传入参数类型是Integer类型的比较内容
     
  •  
    使用sort方法进行规则比较，都需要实现Comparator，只是方式不同
     
 

private void test() {
        //排序字符串集合
        List<String> listS = new ArrayList<>();
        listS.add("2");
        listS.add("5");
        listS.add("3");
        listS.add("7");
        listS.add("4");
        //listS中的对象String本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序
        Collections.sort(listS);
        Log.d("TAG", "listS:" + listS);//[2, 3, 4, 5, 7]
​
        //排序对象元素
        List<Employer1> list1 = new ArrayList<Employer1>();
        Employer1 a1 = new Employer1();
        Employer1 b1 = new Employer1();
        Employer1 c1 = new Employer1();
        a1.setName("a1");
        a1.setAge(44);
        b1.setName("b1");
        b1.setAge(55);
        c1.setName("b1");
        c1.setAge(33);
        list1.add(a1);
        list1.add(b1);
        list1.add(c1);
        Collections.sort(list1, new MyCompare());
        //[name is b1 age is 33, name is a1 age is 44, name is b1 age is 55]
        Log.d("TAG", "list1:" + list1);
​
        List<Employer2> list2 = new ArrayList<Employer2>();
        Employer2 a2 = new Employer2();
        Employer2 b2 = new Employer2();
        Employer2 c2 = new Employer2();
        a2.setName("a2");
        a2.setAge(66);
        b2.setName("b2");
        b2.setAge(33);
        c2.setName("b2");
        c2.setAge(22);
        list2.add(a2);
        list2.add(b2);
        list2.add(c2);
        Collections.sort(list2, new Comparator<Employer2>() {
            @Override
            public int compare(Employer2 o1, Employer2 o2) {
                //比较规则，年龄比较，降序排序(右比左)
                //注意：compareTo方法里面传入Integer类型的比较内容
                return o2.getOrder().compareTo(o1.getOrder());
            }
        });
        //[name is a2 age is 66, name is b2 age is 33, name is b2 age is 22]
        Log.d("TAG", "list2:" + list2);
​
        List<Employer3> list3 = new ArrayList<Employer3>();
        Employer3 a3 = new Employer3();
        Employer3 b3 = new Employer3();
        Employer3 c3 = new Employer3();
        a3.setName("a3");
        a3.setAge(77);
        b3.setName("b3");
        b3.setAge(55);
        c3.setName("b3");
        c3.setAge(99);
        list3.add(a3);
        list3.add(b3);
        list3.add(c3);
        Collections.sort(list3);
        //[name is b3 age is 55, name is a3 age is 77, name is b3 age is 99]
        Log.d("TAG", "list3:" + list3);
​
    }
​
​
    class Employer1 {
        private String name;
        private Integer age;
​
        public void setName(String name) {
            this.name = name;
        }
​
        public Integer getAge() {
            return age;
        }
​
        public void setAge(Integer age) {
            this.age = age;
        }
​
        //重载了Object类里的toString方法，使之可以按照我们要求的格式打印
        @Override
        public String toString() {
            return "name is " + name + " age is " + age;
        }
    }
​
    //比较类
    class MyCompare implements Comparator<Employer1> {
        @Override
        public int compare(Employer1 o1, Employer1 o2) {
            //比较规则，年龄比较，升序排序(左比右)
            return o1.getAge().compareTo(o2.getAge());
        }
    }
​
    class Employer2 {
        private String name;
        private Integer age;
​
        public void setName(String name) {
            this.name = name;
        }
​
        public Integer getOrder() {
            return age;
        }
​
        public void setAge(Integer age) {
            this.age = age;
        }
​
        //重载了Object类里的toString方法，使之可以按照我们要求的格式打印
        @Override
        public String toString() {
            return "name is " + name + " age is " + age;
        }
    }
​
    class Employer3 implements Comparable<Employer3> {
        private String name;
        private Integer age;
​
        public void setName(String name) {
            this.name = name;
        }
​
        public Integer getAge() {
            return age;
        }
​
        public void setAge(Integer age) {
            this.age = age;
        }
​
        //重载了Object类里的toString方法，使之可以按照我们要求的格式打印
        @Override
        public String toString() {
            return "name is " + name + " age is " + age;
        }
​
        //重载了Comparable接口里的compareTo方法来实现具体的比较
        @Override
        public int compareTo(Employer3 a) {//第二个参数（右）
            return this.age.compareTo(a.getAge());
        }
​
    }
 

 

shuffle
 

对集合进行随机排序 （有可能排序过的集合元素位置不变）
 

public void shuffle(){
    List c = new ArrayList();
    c.add("w");
    c.add("o");
    c.add("r");
    c.add("l");
    c.add("d");
    Log.d("TAG", "初始集合："+c);//[w, o, r, l, d]
​
    Collections.shuffle(c);
    Log.d("TAG", "随机一集合："+c);//[l, o, d, w, r]
​
    Collections.shuffle(c);
    Log.d("TAG", "随机二集合："+c);//[r, w, o, l, d]
}
 

max
 

前者采用Collection内含自然比较法，后者采用Comparator进行比较
 

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
 

min
 

前者采用Collection内含自然比较法，后者采用Comparator进行比较
 

public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
 

copy
 

将集合n中的元素全部复制到m中,并且覆盖相应索引的元素 （从0开始覆盖，后面的元素向后移）
 

public void copy() {
    List m = Arrays.asList("one two three four five six siven".split(" "));
    Log.d("TAG", "初始集合：" + m);//[one, two, three, four, five, six, siven]
    List n = Arrays.asList("我是 复制 过来的哈".split(" "));
    Log.d("TAG", "待复制集合：" + n);//[我是, 复制, 过来的哈]
    Collections.copy(m, n);
    Log.d("TAG", "复制后集合：" + m);//[我是, 复制, 过来的哈, four, five, six, siven]
}
 


                

        

        

    

  


    

      

        

            

              
                
                  自由自在1039
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Java集合框架

				
			

			

				

					qq_51772112的博客
				

				

					08-11
					
					7266
					
				

			

		

		

			
				
集合

概念


1、 集合是Java API所提供的一系列类，可以用于动态存放多个对象。--集合只能存对象

2、 集合与数组的不同在于，集合是大小可变的序列，而且元素类型可以不受限定，只要是引用类型。(集合中不能放基本数据类型，但可以放基本数据类型的包装类)

3.集合类全部支持泛型，是一种数据安全的用法。




集合框架图







Iterator迭代器


Iterator<String> it = list.iterator();
while (it.hasNext()) {.

			
		

	



                

              
                



	

		

			

				
					
Java 集合框架

				
			

			

				

					m0_60815774的博客
				

				

					09-02
					
					111
					
				

			

		

		

			
				
集合的概述

程序储存书籍的方式

 集合：丰富多样的强大的数据存储（java 提供的一大堆 API）

集合的体系结构

接口Collection：存储的是可重复（不唯一）、无须的数据

 接口List：存储的是可重复（不唯一），有序的数据使用接口要找到他们的实现类

 Arratlist

 LinkendList

 .........

 接口Set：存储的是不可重复（...

			
		

	



                


  
              

                


	

		

			

				
					
【Java集合框架库】集合概述

				
			

			

				

					Sampson_S的博客
				

				

					04-16
					
					296
					
				

			

		

		

			
				
集合
集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。Java集合类是Java将一些基本的和使用频率极高的基础类进行封装和增强后再以一个类的形式提供。集合类是可以往里面保存多个对象的类，存放的是对象，不同的集合类有不同的功能和特点，适合不同的场合，用以解决一些实际问题。
集合和数组的区别：

集...

			
		

	





	

		

			

				
					
JAVA集合框架

				
			

			

				

					lilong329329的博客
				

				

					04-04
					
					273
					
				

			

		

		

			
				
首先设计集合框架需要满足以下几个条件：
1、该框架必须是高性能的（基本集合动态数组、链表、树、哈希表）的实现也必须是高性能的
2、该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性
3、对一个集合的扩展和适应必须是简单的
因此，整个集合框架就围绕一组标准接口而设计的，你可以直接使用这些接口的标准实现，例如LinkedList，HashSet、和TreeSet等，除此之外也可以通

			
		

	



		

			
		



	

		

			

				
					
Java-集合框架-学习总结

				
			

			

				

					Rookie20190715的博客
				

				

					07-31
					
					205
					
				

			

		

		

			
				
Java 集合框架
集合框架被设计成要满足以下几个目标。
该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。
该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。
对一个集合的扩展和适应必须是简单的

集合框架主要有两种类型的容器，一是集合（collection），存储一个元素集合，另外一个是图（map），存储键/值对映射。
Collection 接口有...

			
		

	





	

		

			

				
					
【Java】Java集合框架思维导图。

				
			

			

				

					04-13
				

			

		

		

			
				
xmind格式的Java集合框架学习导图，包括Collection接口/Map接口以及具体实现类。 同样包含大厂面试题，也在导图中有所体现。 能学到什么： 更加成体系的知识框架，更加全面的、系统的知识。 思维导图： 思维导图具有...

			
		

	





	

		

			

				
					
JAVA集合框架专题

				
			

			

				

					08-19
				

			

		

		

			
				
JAVA集合框架专题  JAVA集合框架是JAVA编程语言中的一种常用的数据结构，用于存储和操作对象信息。下面是JAVA集合框架的主要知识点：  一、集合框架概述  JAVA集合框架是一种容器，用于存储对象信息。所有集合类都...

			
		

	





	

		

			

				
					
java 集合框架

				
			

			

				

					09-29
				

			

		

		

			
				
Java集合框架，set、list接口及其子集，接口的继承关系

			
		

	





	

		

			

				
					
【学习笔记】手写 Tomcat 三

				
			

			

				

					LearnTech_123的博客
				

				

					09-12
					
					1119
					
				

			

		

		

			
				
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin

			
		

	





	

		

			

				
					
Gradle

				
			

			

				

					xiaocaij_icai的博客
				

				

					09-15
					
					157
					
				

			

		

		

			
				
");

			
		

	





	

		

			

				
					
基于SpringBoot的考研资讯平台设计与实现

				
			

			

				

					linzhongshu的专栏
				

				

					09-13
					
					892
					
				

			

		

		

			
				
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。

			
		

	





	

		

			

				
					
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试

				
			

			

				

					weixin_19164791635
				

				

					09-12
					
					928
					
				

			

		

		

			
				
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。

			
		

	





	

		

			

				
					
spring security中几大组件的作用和执行顺序

				
			

			

				

					阿信今天的代码没bug的博客
				

				

					09-11
					
					349
					
				

			

		

		

			
				
spirng security中的几大组件的差异和执行顺序

			
		

	





	

		

			

				
					
模拟面试后端开发复盘

				
			

			

				

					Java小白的博客 致力分享每一天学到的知识
				

				

					09-11
					
					1210
					
				

			

		

		

			
				
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。

			
		

	





	

		

			

				
					
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试

				
			

			

				

					weixin_19164791635
				

				

					09-16
					
					854
					
				

			

		

		

			
				
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。

			
		

	





	

		

			

				
					
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息

				
			

			

				

					Dynadot_tech的博客
				

				

					09-12
					
					1073
					
				

			

		

		

			
				
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。

			
		

	





	

		

			

				
					
07_Python数据类型_集合

					
最新发布

				
			

			

				

					fx_yzjy101的专栏
				

				

					09-16
					
					422
					
				

			

		

		

			
				
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。

			
		

	





	

		

			

				
					
深入理解Java集合框架

				
			

			

				

					
				

			

		

		

			
				
"Java集合框架总结"  Java集合框架是Java编程语言中用于处理对象集合的重要工具，它提供了一种组织和操作数据的标准方式。这个框架包括了多种接口、实现类和算法，使得开发者能够灵活地选择合适的数据结构来存储和...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
自由自在1039

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值