JAVA学习笔记整理六（类集框架）

最新推荐文章于 2024-05-29 11:07:03 发布
最新推荐文章于 2024-05-29 11:07:03 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： Java基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Friday_577/article/details/51544034
版权

类集框架接口的具体特点


接口的继承关系

集合框架中的实现类

Collection接口

1.    此接口是单值存放的最大父类接口，可以向其中保存多个单值（单个的对象）数据，一般不直接使用，因为表示的操作意义不明确。

2.    使用了泛型的定义，在操作时必须指定具体的操作类型，以保证类集操作的安全性，避免发生ClassCastException异常

List接口

1.     ArrayList：

public class ArrayListTest {
	public static void main(String[] args) {
		List
    
    
     
      list = new ArrayList
     
     
      
      ();
		list.add("Hello");
		list.add("Hello");
		list.add(1,"World");//在第1个位置（即第一个数据之后，以0——(size()-1)计数）
		list.add(3,"Java");//在第3个位置添加
		
		System.out.println(list);
		System.out.println("集合中有多少数据：" + list.size());
		System.out.println("集合中是否有Java:" + list.contains("Java"));//此处区分大小写
		System.out.println("得到第几位的元素" + list.get(2));
		System.out.println("Java字符串的位置：" + list.indexOf("Java"));
		
		String[] strs = list.toArray(new String[] {});// 集合转指定类型的数组
		for (Object str : strs) {
			System.out.print(str + ", ");
		}
		System.out.println();
		String[] arr = { "hello", "java", "hello", "jsp"};
		List
      
      
       
        list1 = Arrays.asList(arr);//数组转列表（大小固定，为数组大小）
		System.out.println("数组转列表:" + list1);
		
		List
       
       
        
         subList=list.subList(1, 3);//返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图
		System.out.println(subList);
		
		Collection
        
        
          coll = new ArrayList<>(); coll.add("Hello"); coll.add("SQL"); list.addAll(coll);// 将coll集合中的所有元素添加至list System.out.println("将coll集合中的所有元素添加至list:" + list); System.out.println("list是否包含coll：" + list.containsAll(coll)); // list.removeAll(coll);//从list中删除两个集合的交集 // System.out.println("删除两个集合的交集后:" + list);//删除两个集合的交集后:[World, Java] list.retainAll(coll);//保留交集，其余删除 System.out.println("保留交集，其余删除后:" + list); list.remove("Hello");//删除'Hello' System.out.println("删除'Hello'后：" + list);//只删除第一个 list.clear(); System.out.println("清空所有元素后：" + list); System.out.println("集合是否为空：" + list.isEmpty()); } } //[Hello, World, Hello, Java] //集合中有多少数据：4 //集合中是否有Java:true //得到第几位的元素Hello //Java字符串的位置：3 //Hello, World, Hello, Java, //数组转列表:[hello, java, hello, jsp] //[World, Hello] //将coll集合中的所有元素添加至list:[Hello, World, Hello, Java, Hello, SQL] //list是否包含coll：true //保留交集，其余删除后:[Hello, Hello, Hello, SQL] //删除'World'后：[Hello, Hello, SQL] //清空所有元素后：[] //集合是否为空：true

2.     LinkedList:

public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList
    
    
     
      ll = new LinkedList
     
     
      
      ();
		ll.add("A");
		ll.add("B");
		ll.add("C");
		System.out.println("初始化列表：" + ll);
		
		ll.addFirst("X");//在链表的表头增加数据
		ll.addLast("Y");//在链表的表尾增加数据
		System.out.println("增加头和尾之后的链表：" + ll);
		
		System.out.println("element找到的表头：" + ll.element());//element()表示获取但不移除此列表的头
		System.out.println("element找完之后：" + ll);
		System.out.println("peek找到的表头：" + ll.peek());//获取但不移除此列表的头（第一个元素）
		System.out.println("peek找完之后：" + ll);
		System.out.println("poll找到的表头：" + ll.poll());//获取并移除此列表的头（第一个元素）
		System.out.println("poll找完之后：" + ll);
		
		ll.offer("g");//将指定元素添加到此列表的末尾
		System.out.println("添加指定元素之后的链表：" + ll);
		Collections.fill(ll, "x");//使用指定元素替换指定列表中的所有元素
		System.out.println("替换之后的链表：" + ll);
	}
}

//初始化列表：[A, B, C]
//增加头和尾之后的链表：[X, A, B, C, Y]
//element找到的表头：X
//element找完之后：[X, A, B, C, Y]
//peek找到的表头：X
//peek找完之后：[X, A, B, C, Y]
//poll找到的表头：X
//poll找完之后：[A, B, C, Y]
//添加指定元素之后的链表：[A, B, C, Y, g]
//替换之后的链表：[x, x, x, x, x]

3.     区别：

    1）  我们可以将ArrayList看作是能够自动增长容量的数组，可以直接利用ArrayList的toArray()返回一个数组

    2）  ArrayList底层采用数组完成，而LinkedList则是以一般的双向链表(double-linked list)完成，其内每个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素

    3）  LinkedList在实现List接口的同时，还实现了Queue接口，采用“先进先出”的方式操作

   4） 如果我们经常在List的开始处增加元素，或者在List中进行插入和删除操作，我们应该使用LinkedList，否则的话，使用ArrayList将更加快速

Set接口

Set接口不能增加重复元素，实例无法像List接口那样可以进行双向输出。

1.     HashSet：散列的存放：不能存放重复元素，并且采用散列的存储方式，无序排列

2.     TreeSet：有序的存放：不能存放重复元素，有序排列，可以自定义类进行去重复并按照自己规定的顺序进行排序

3.     TreeSet实现了SorteSet接口（是 SorteMap 的 set 对应接口） 
public class SetTest {
	public static void main(String[] args) {
		
     // hashSet
     Set
    
    
     
      hashSet = new HashSet
     
     
      
      ();
		hashSet.add("A");
		hashSet.add("A");
		hashSet.add("B");
		hashSet.add("C");
		hashSet.add("C");
		hashSet.add("D");
		System.out.println("hashSet：" + hashSet);
		// hashSet：[D, A, B, C]

	// treeSet
     Set
      
      
       
        treeSet = new TreeSet
       
       
        
        ();
		treeSet.add("D");
		treeSet.add("A");
		treeSet.add("C");
		treeSet.add("D");
		treeSet.add("B");
		treeSet.add("A");
		System.out.println("treeSet：" + treeSet);
		// treeSet：[A, B, C, D]
		
     // myTreeSet
		Set
        
        
          myTreeSet = new TreeSet 
         
           (); myTreeSet.add(new Child("张三", 18)); myTreeSet.add(new Child("李四", 20)); myTreeSet.add(new Child("王五", 21)); myTreeSet.add(new Child("王五", 21)); myTreeSet.add(new Child("张三", 19)); myTreeSet.add(new Child("张三", 18)); System.out.println("myTreeSet:" + myTreeSet); // myTreeSet:[姓名：张三==年龄：18, 姓名：张三==年龄：19, //姓名：李四==年龄：20, 姓名：王五==年龄：21] // SortedSet SortedSet 
          
            sortedSet = new TreeSet 
           
             (); sortedSet.add("A"); sortedSet.add("B");//同样不能放入重复 sortedSet.add("B"); sortedSet.add("C"); sortedSet.add("A"); sortedSet.add("D"); sortedSet.add("E"); System.out.println("第一个元素：" + sortedSet.first());//第一个元素：A System.out.println("最后一个元素：" + sortedSet.last());//最后一个元素：E System.out.println("headSet元素：" + sortedSet.headSet("C")); //C的前面，不包括C headSet元素：[A, B] System.out.println("tailSet元素：" + sortedSet.tailSet("C")); //C的后面，包括 CtailSet元素：[C, D, E] System.out.println("subSet元素：" + sortedSet.subSet("B", "D")); //B、D中间，包含B不包含D subSet元素：[B, C] } } class Child implements Comparable 
            
              { // TreeSet中为有序排列，所以对于自定义的类使用TreeSet进行存放时， //对于一个对象必须指定好排序规则，需要实现Commparable接口才能正常使用 private String name; private int age; public Child(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "姓名：" + this.name + "==年龄：" + this.age; } @Override public boolean equals(Object obj) {// 比较方法重载，用于进行比较两个对象，并去除重复对象 if (this == obj) {// 地址相等 return true;// 是同一个对象 } if (this == null) {// 地址为空 if (obj != null) return false;// 不是同一个对象 } Child temp = (Child) obj;// 进行向下转型 if ((this.name.equals(temp.name)) && (this.age != temp.age)) {// 依次判断属性是否相等 return true;// 全部相等，是一个对象 } else { return false; } } @Override public int hashCode() {// 对于重复的判断，只覆写equals方法不够，还需要覆写hashCode方法， //利用指定的公式将类中全部属性进行计算，以求出一个不会重复的哈希码，从而判断不重复 return this.name.hashCode() * this.age;// 指定哈希码编写公式 } @Override public int compareTo(Child o) { if (this == o) {// 地址相等 return 0;// 相等返回0，大于返回正数，小于返回负数 } if (this == null) {// 地址为空 if (o != null) return -1; } if (!this.name.equals(o.name)) {// 姓名不相等则按姓名排 return this.name.compareTo(o.name);// 按字典顺序比较两个字符串 } // return o.age - this.age;// 年龄按从o到this的顺序排 return this.age - o.age;// 年龄按从this到o的顺序排 } }

集合的输出

1.     迭代输出 Iterator（最常使用）：是专门的迭代输出接口，由前向后单向输出。所谓的迭代输出接口就是将元素一个个进行判断，判断其是否有内容，如果有内容则把内容取走

2.     双向迭代输出Listlterator：可以实现由后向前或者由前向后的双向输出（只有List接口才可以实现），若想要后向前输出，必须先完成由前向后的输出

3.     Foreach：增强型循环 
public class IteratorTest {
	public static void main(String[] args) {
		
		//Iterator代码
		List
     
     
      
       list = new ArrayList<>();
		list.add("Hello");
		list.add("World");
		list.add("Hello");
		list.add("Java");
		Iterator
      
      
       
        itr = list.iterator();//直接实例化Iterator接口
		while (itr.hasNext()){// 是否有下一个数据
			String str = itr.next();
			if("Java".equals(str)){//判断内容里是否有“I”
				itr.remove();//如果有就删除该元素
			}
		}
		System.out.println("使用Iterator：" + list);
		
		//ListIterator代码
		System.out.println("========================");
		List
       
       
        
         list1 = new ArrayList
        
        
         
         ();
		list1.add("Hello");
		list1.add("World");
		list1.add("Hello");
		list1.add("Java");
		ListIterator
         
         
           litr = list1.listIterator(); System.out.print("使用ListIterator由前向后输出："); while (litr.hasNext()) { String string = litr.next(); System.out.print(string + "、"); } System.out.println(); System.out.print("使用ListIterator由后向前输出："); while (litr.hasPrevious()) { String string = litr.previous(); System.out.print(string + "、"); } //Foreach代码 System.out.println(); System.out.println("========================="); List 
          
            list2 = new ArrayList 
           
             (); list2.add("Hello"); list2.add("World"); list2.add("Hello"); list2.add("Java"); System.out.print("使用foreach输出："); for (String str : list2) { System.out.print(str + "、"); } } } //使用Iterator：[Hello, World, Hello] //======================== //使用ListIterator由前向后输出：Hello、World、Hello、Java、 //使用ListIterator由后向前输出：Java、Hello、World、Hello、 //========================= //使用foreach输出：Hello、World、Hello、Java、


Map:

Collection、Set、List接口都属于单值的操作，每次只能操作一个对象，而Map每次操作的是一对对象，Map的每个元素都用key→value的形式存储在集合中

1.     Map.Entry接口简介：是Map内部定义的一个接口，专门用来保存key→value的内容（实际上是将key→value的数据保存在Map.Entry的实例后，再在Map集合中插入一个个的Map.Entry的实例化对象）


2.     HashMap：无序存放，新的操作类，key不允许重复

3.     HashTable：无序存放，旧的操作类，key不允许重复（除了Hashtable可以同步和不允许使用null之外， Hashtable与HashMap类大致相同）


4.     TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复（一般使用的String类作为key，而String类已经实现了Comparable接口，所以不用再特意实现，而如果使用自定义的类作为key，则必须实现Comparable接口，否则会出现异常） 
public class MapTest {
	public static void main(String[] args) {
		
		//HashMap代码
		Map
     
     
      
       map = null;
		map = new HashMap
      
      
       
       ();
		map.put("a", 97);
		map.put("b", 98);
		map.put("c", 99);
		map.put("d", 100);
		map.put(null, null);//HashMap允许放入null，而HashTable不可以
		
		System.out.println(map);
		map.put("a", 0);// 会将之前相同Key值的value值覆盖
		System.out.println(map);
		System.out.println("字母a的ASCII码:" + map.get("a"));//根据key值得到value值
		System.out.println("有没有b的ASCII码:" + map.containsKey("b"));//查找指定的key是否存在
		System.out.println("有没有ASCII码等于100的字母：" + map.containsValue(100));//查找指定的value是否存在
		System.out.println("map是否为空：" + map.isEmpty());
		System.out.println("map中有多少数据：" + map.size());
		map.remove("d");
		System.out.println("删掉d后，map中有多少数据：" + map.size());

		System.out.println("===============================");
		Set
       
       
        
         keys = map.keySet();//得到全部的key
		System.out.print("全部的key：");
		for (String k : keys) {//利用增强型循环输出
			if("a".equals(k)){
				map.put("a", 55);//利用put将a的值更改
			}
			System.out.print(k + "、");
		}
		System.out.println();
		Collection
        
        
         
          values = map.values();//得到全部的value
		Iterator
         
         
           itr1 = values.iterator();//利用Iterator进行输出 System.out.print("全部的value："); while(itr1.hasNext()){ Integer string1 = itr1.next(); System.out.print(string1 + "、"); } System.out.println(); System.out.println("================================"); map.clear(); System.out.println("清空操作后，map是否为空：" + map.isEmpty()); Map 
          
            map1 = new HashMap<>(); map1.put("q", 7); map1.put("w", 8); map1.put("e", 9); map.putAll(map1);//将map1的所有数据放入map中 System.out.println("放入map1后的map：" + map); System.out.println("map1：" + map1); System.out.println(); Set 
            
            
              > entrys = map.entrySet();//可以同时得到key与value的值的列表 for (Map.Entry 
             
               entry : entrys) { System.out.println("key:" + entry.getKey() + " value:" + entry.getValue()); } //TreeMap代码 System.out.println("============================"); Map 
              
                treeMap = new TreeMap 
               
                 (); treeMap.put("C", "张三"); treeMap.put("A", "李四"); treeMap.put("B", "李四"); treeMap.put("A", "王五"); Set 
                
                  treeSet = treeMap.keySet(); Iterator 
                 
                   treeItr = treeSet.iterator(); while(treeItr.hasNext()){ String treeStr = treeItr.next(); System.out.println(treeStr + "--->" + treeMap.get(treeStr));//取出key对应的key值 } } } //{null=null, d=100, b=98, c=99, a=97} //{null=null, d=100, b=98, c=99, a=0} //字母a的ASCII码:0 //有没有b的ASCII码:true //有没有ASCII码等于100的字母：true //map是否为空：false //map中有多少数据：5 //删掉d后，map中有多少数据：4 //=============================== //全部的key：null、b、c、a、 //全部的value：null、98、99、55、 //================================ //清空操作后，map是否为空：true //放入map1后的map：{w=8, e=9, q=7} //map1：{w=8, e=9, q=7} // //key:w value:8 //key:e value:9 //key:q value:7 //============================ //A--->王五 //B--->李四 //C--->张三

5.     WeekHashMap：弱引用，之前的子类都是强引用保存，即里面的内容不管是否使用都始终在集合里，而WeekHashMap则当利用“System.gc()”进行垃圾收集时，集合会自动清理暂时不用的数据


6.     Key可以重复的Map集合：IdentityHashMap

        只要key地址不是相等的，就可以添加进去而不被覆盖

Map接口使用的注意事项

1.     不能直接使用迭代输出Map中的全部内容（Map一般很少直接输出，只是作为查询使用，而Collection接口一般用来传递内容和输出）

   1）    使用Iterator输出（最标准的操作流程）

1>  将Map的实例通过entrySet方法变为Set接口对象

2>  通过Set接口实例化为Iterator实例化

3>  通过Iterator迭代输出，每个内容都是Map.Entry的对象

4>  通过Map.Entry进行key→value的分离 
Set
     
     
      
       treeSet = treeMap.keySet();
		Iterator
      
      
       
        treeItr = treeSet.iterator();
		while(treeItr.hasNext()){
			String treeStr = treeItr.next();
			System.out.println(treeStr + "--->" + treeMap.get(treeStr));

   2）    Foreach输出（将Map集合变为Set集合进行输出）

Set
    
    
     
     
      
      > entrys = map.entrySet();//可以同时得到key与value的值的列表
		for (Map.Entry
      
      
       
        entry : entrys) {
			System.out.println("key:" + entry.getKey() + " value:" + entry.getValue());

2.     直接使用非系统的类作为key

        如果使用的自定义的类表示Map中的value，则按照格式完成即可，但是，如果要使用一个自定义的对象表示Map中的key，则对象所在的类中一定要覆写equals()和hashCode()方法，否则无法找到对应的value（类似于treeSet处，需要一一进行比较）

其他集合类

1.     Stack类：栈，先进后出。

2.     属性类：Properties

public class PropertiesDemo {
	public static void main(String[] args) {
		Properties prop = new Properties();
		prop.setProperty("system.language", "zh_CN");//设置属性
		prop.setProperty("color", "red");
		prop.setProperty("font", "黑体");
		prop.setProperty("font.style", "bold");
		
		System.out.println("配置的颜色"+prop.getProperty("color"));//根据key值取得属性的value，如果没有则返回null
		System.out.println("字体样式"+prop.getProperty("style"));//未找到则返回null
		
		String style = prop.getProperty("style","normal");
		System.out.println("字体样式"+style);
		
		prop.list(System.out);//将属性按列表输出到指定的输出流（此处为控制台）
		try {
			prop.store(new FileOutputStream("c:config.txt"), "系统配置");
			//将prop中的配置保存到C盘中的config文件中，并设置注释内容
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

//配置的颜色red
//字体样式null
//字体样式normal
//-- listing properties --
//font.style=bold
//color=red
//font=黑体
//system.language=zh_CN
Friday_577
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 类集(很全)
05-25
Java 类集，很详细，欢迎下载
Java集合框架的知识总结（1）-转载
BugMaker的专栏
03-17 551
说明：先从整体介绍了Java集合框架包含的接口和类，然后总结了集合框架中的一些基本知识和关键点，并结合实例进行简单分析。 1、综述         所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。        当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行
2024年7款最佳 Java 框架
最新发布
2401_85112058的博客
05-29 1346
在其完全拥抱 MVC框架之后，Spring 不断的发展与变化着，转变成了一个功能全面的面向互联网应用程序的Java框架, 它能提供给软件工程师的是一个用于web应用程序开发的强大工具集，以及针对安全项目的应用程序配置。Apache软件基金会为开发人员提供了一个广泛的工具，用于创建企业级的面向Web的应用程序，开发过程的优化从开始贯彻到结束，还提供后期的维护。不管文档有多少，Spring MVC都可能并非是一个Java开发的新手能掌控的，尽管这并不是框架的一个直接缺陷，但学习曲线真的是有点太陡了。
Java—类集框架
LiLi的博客
08-07 636
Java的类集框架可以使程序处理对象的方法标准化，类集接口是构造类集框架的基础，使用迭代方法访问类集可以使对类集的操作更高效。 认识类集框架 在基础应用中，通常我们可以通过数组来保存一组具有相同属性的对象或者基本类型的数据，但使用数组的弊端在于其大小是不可更改的，因此出于灵活性的考虑，可以使用链表来实现动态的数组。任何事情都有两面性，灵活性的代价就是操作上的繁琐。在计算机世界里，处理繁琐问题的常用方法就是将其封装，只向外提供可调用的方法视图。Java类集框架就是对这一方法的一种官方实现—套动态对象数组的操作
Java类集框架
lexajeQath的博客
05-13 741
类集框架图解： 前言： 数据结构对程序设计有着深远的影响，在面向过程的c语言中，数据库结构用struct来描述，而在面向对象的编程中，数据结构是用类来描述的，并且包含对该数据结构操作的方法。在Java语言中，Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（具体实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为Java集合框架。Java程序员在具体应用时，不必考虑
Java 类集框架
林贻民的博客
02-26 2402
概念类集是一种动态的对象数组，属于各个数据结构的实现类，整个类集的主要组成是一些核心的操作接口：Collection，List，Set，Map，Iterator和Enumeration．以下是部分类集框架的继承结构图：注:Collection接口设置完内容的目的是为了输出，Map接口设置完内容的目的是为了查找\color{red}{Collection接口设置完内容的目的是为了输出，Map接口设置完
Java学习笔记整理
05-21
这些学习笔记将带你深入了解Java的核心概念，特别是面向对象编程和集合框架。以下是对每个文件内容的详细阐述： 1. **Day0804_HashMap的基本使用.docx**：HashMap是Java集合框架中的一个重要组件，它提供了键值对的...
JAVA学习笔记整理(全)
06-03
JAVA学习笔记整理全面涵盖了从基础语法到高级技术的多个领域，包括数据库管理、Web服务器、缓存技术、框架、容器、网络、虚拟机、操作系统、数据结构和操作系统等多个方面。以下将详细介绍其中的关键知识点。 一、...
最全的java学习笔记整理
08-08
从零开始学习Java，首先需要了解编程语言的基本概念，包括如何通过编程解决实际问题。Java的特点在于它的“一次编写，到处运行”（Write Once, Run Anywhere）特性，这得益于Java虚拟机（JVM），它允许编译后的Java...
java笔记整理(超详细) java笔记整理(超详细)
07-14
Java是一种广泛使用的高级编程语言，以其面向对象的特性、跨平台的兼容性和强大的功能而闻名。...以上知识点涵盖了Java的基本特性、核心概念以及一些高级特性，理解这些将有助于深入学习和使用Java进行软件开发。
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java集合类框架
JackChan
01-05 799
原文出处：于卫国，http://yuweiguocn.github.io/java-collection/Java集合类框架概览及各集合之间的区别。 集合中存放的是对象的引用。 Collections：集合的搜索、排序、线程安全化等Collection接口 boolean add(Object o) boolean addAll(Collection c) boolean remove(Obje
Java集合框架
03-12 1655
Java集合框架 类集的概念是在JDK1.2之后正式完善的一套开发架构，基本的作用是完成一个动态的对象数组，里面的数据元素可以动态增加。 注意：Java集合只能存放对象，不能存放其本数据类型，就算是放了基本数据类型也会自动进行打包，更不能存放变量。  Collection接口（重点） Collection接口是一个重要的操作接口，其中规定了一个集合的基本操作方法，此接口有2
JAVA 类集
松篁
01-02 118
类集的概念是从JDK 1.2 之后正式完善的一套开发架构，其基本的作用就是完成了一个动态的对象数组，里面的数据元素可以动态的增加 类集提供了以下的几种接口： 单值操作接口：Collection、List、Set List 和 Set 是Collection 接口的子接口 一对值的操作接口：Map 排序的操作接口：SortedMap、SortedSet 输出的接口：Iterator、Li...
JAVA类集框架
qq_53578500的博客
04-15 241
JAVA类集框架 一.基本概念 在讲解类集概念前，先来思考这样一个问题， 如果现在要保存一组对象， 按照之前的做法则只能使用对象数组，一但是使用对象数组操作本身有一个限制， 就是数组有长度的限制:而通过一些数据结构的操作，如链表，则可以完成动态对象数组的操作，但是这些如果全部由开发人员来做，则肯定是比较麻烦的。 　　类集框架恰好解决了 上面的难题，所谓类集就是一个动态的对象数组，是对一些实现好的数据结构进行了包装，这样在使用时就会非常方便，而且最重要的是类集框架本身不受对象数组的长度限制。 注：数组最大的缺
JAVA集合小结
烂锅烂铁
11-09 78
[img]http://dl.iteye.com/upload/attachment/345325/0440d049-f3ba-3ad6-a98c-5c18a56eb930-thumb.jpeg[/img] [img]http://dl.iteye.com/upload/attachment/345327/3499f455-db56-3798-99b4-bf62b96ff473-thumb.jp...
Java之路：Java类集框架
星云999的博客
12-10 536
一、认识类集框架 二、类集接口 三、Collection——单值保存的最大父类接口 四、Collection接口的具体实现类 五、允许重复的子接口——List 1、ArrayList类 2、LinkedList类 3、Vector类 六、数组操作类——Arrays 七、比较器 1、Comparable接口 2、挽救的比较器接口——Comparator Java的类集框架可以使程序...
JAVA 类集框架
ZengYan
03-16 537
什么是类集框架 集合（set）：集合中的对象不按特定方式排序，并且没有重复对象。 列表（list）：集合中对象按照索引位置排序，可以有重复的对象。 映射（Map）：集合的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复。急速键值对。 先看看类集框架的整个的图 可见，类集接口的主要有两个主要接口collection和iterator。 想学会类集框架
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值