- 浏览: 56724 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (218)
- ★★★ Android ★★★ (37)
- 【 Java 基础】✚ (0)
- ☞Java 基础概述 (0)
- ☞Java 基本语法 (0)
- ☞Java 面向对象编程 (0)
- ☞Java多线程 (0)
- ☞Java 异常处理 (0)
- ☞Java 集合框架 (0)
- ☞Java 泛型 (0)
- ☞Java 枚举和注解 (0)
- ☞Java IO流 (0)
- ☞Java 常用类 (0)
- ☞Java GUI键盘事件 (0)
- ☞Java 网络编程 (0)
- ☞Java 正则表达式 (0)
- ☞Java 反射机制 (0)
- ☞Java 小项目 (0)
- ☞Java 面试/笔试题 (0)
- 【HTML5 开发基础】✚ (0)
- ☞HTML常用标签 (0)
- ☞HTML 新特性 (0)
- ☞CSS/CSS3常用语法 (0)
- ☞JavaScript基础语法 (0)
- ☞HTML5 小项目 (0)
- ☞HTML5 面试/笔试题 (0)
- 【Android 基础阶段】✚ (12)
- ☞Android 快速入门 (1)
- ☞Android 核心组件 (1)
- ☞Android Intent (0)
- ☞Android 用户界面 (5)
- ☞Android 数据存储 (0)
- ☞Android Tomcat服务器 (0)
- ☞Android 网络编程 (2)
- ☞Android 消息机制 (0)
- ☞Android 事件机制 (0)
- ☞Fragment和ViewPager (3)
- ☞Android动画与图形处理 (0)
- ☞Android多媒体应用开发 (1)
- ☞Android 传感器开发等 (0)
- ☞Android GPS应用 (0)
- ☞Android C语言 (0)
- ☞Android JNI/NDK开发 (0)
- ☞Android Git/SVN (0)
- ☞Android 小项目 (0)
- ☞Android 面试/笔试题 (0)
- 【Android 微知识点】✚ (7)
- ☞Android 一些模版代码 (0)
- ☞Android 模块功能代码 (0)
- ☞Android UI控件大全 (2)
- ☞Android 自定义适配器 (1)
- ☞Android 自定义属性 (3)
- ☞Android 自定义动画 (0)
- ☞Android 启动过程 (0)
- ☞Android 性能优化 (0)
- ☞Android 图片三级缓存 (0)
- ☞Android 屏幕适配 (0)
- ☞Android OOM内存溢出 (0)
- ☞Android 权限 (0)
- ☞Android JNI (0)
- 【Android 网络编程】✚ (1)
- ☞Android Json解析 (2)
- ☞Android 网络请求 (2)
- 【Android 解析器】✚ (0)
- ☞Android XML (0)
- ☞Android DOM (0)
- ☞Android dom4j (0)
- ● (0)
- ●● (0)
- ●●● (0)
- ●●●● (0)
- ●●●●● (0)
- ●●●●●● (0)
- ●●●●●●● (0)
- ●●●●●●●● (0)
- ●●●●●●●●● (0)
- ☞☞☞☞☞☞☞☞☞☞ (0)
- ☞☞☞☞☞☞☞☞☞ (0)
- ☞☞☞☞☞☞☞☞ (0)
- ☞☞☞☞☞☞☞ (0)
- ☞☞☞☞☞☞ (0)
- ☞☞☞☞☞ (0)
- ☞☞☞☞ (0)
- ☞☞☞ (0)
- ☞☞ (0)
- ☞ (0)
- 【Android重量级框架】✚ (14)
- ☞框架归类 (1)
- ☞Gson (0)
- ☞xUtils3 (2)
- ☞xListView (0)
- ★ Volley (0)
- ★ AndroidAnnotations (0)
- ★ Glide (0)
- ★ SlidingMenu (0)
- ★ TabLayout (1)
- ★ ViewPagerIndicator (4)
- ★ Pulltorefresh (1)
- ★ PhotoView (1)
- ★ EventBus (0)
- ★ Vitamio5.0 (0)
- ★ Image-Loader (1)
- ★ Android-gif-drawable (0)
- ★ ActionBar (0)
- ★ ActionBarSherlock (0)
- ★ OkHttp (0)
- ★ Afinal (2)
- ★ Ffmpeg (0)
- ★ RxJava (0)
- ★ Picasso (0)
- ★ FastJson (0)
- ★ Toolbar (0)
- ★ GreenDao (0)
- ★ Otto (0)
- ★ ORMLite (0)
- ★ Retrofit (0)
- ★ Fresco (0)
- ★ SnappyDB (0)
- ★ Butterknife (0)
- ★ PagerSlidingTabStrip (0)
- PinterestLikeAdapterView (0)
- ★ NotBoringActionBar (0)
- ★ StickyListHeaders (0)
- ★ NineOldAndroids (0)
- ★ Expandablelistview (0)
- ★ SwipeRefreshLayout (0)
- ★ SwipeMenuListView (0)
- ★ (0)
- ★★ (0)
- ★★★ (0)
- ★★★★ (0)
- ★★★★★ (0)
- ★★★★★★ (0)
- ★★★★★★★ (0)
- ★★★★★★★★ (0)
- ★★★★★★★★★ (0)
- ★★★★★★★★★★ (0)
- ❉❉❉❉❉❉❉❉❉❉ (0)
- ❉❉❉❉❉❉❉❉❉ (0)
- ❉❉❉❉❉❉❉❉ (0)
- ❉❉❉❉❉❉❉ (0)
- ❉❉❉❉❉❉ (0)
- ❉❉❉❉❉ (0)
- ❉❉❉❉ (0)
- ❉❉❉ (0)
- ❉❉ (0)
- ❉ (0)
- 【第三方分享库】✚ (0)
- ○○○○○○○○○○ (0)
- ○○○○○○○○○ (0)
- ○○○○○○○○ (0)
- ○○○○○○○ (0)
- ○○○○○○ (0)
- ○○○○○ (0)
- ○○○○ (0)
- ○○○ (0)
- ○○ (0)
- ○ (1)
- 【Android开源项目】✚ (1)
- ☞综合性项目 (0)
- ☞多媒体项目 (1)
- ☞新闻性项目 (2)
- ☞社交性项目 (0)
- ☞商城性项目 (0)
- ☞Android 支付宝 (0)
- ☞Android 第三方登录 (0)
- ☞Android 语音识别 (0)
- ☞Android消息推送 (1)
- ☞Android 蓝牙 (0)
- ☞Android 传感器 (0)
- ☞Android 动画 (0)
- ☞Android 省市县三级联动 (0)
- ☞短信验证技术 (0)
- ☞二维码扫描技术 (0)
- ☂ (0)
- ☂☂ (0)
- ☂☂☂ (0)
- ☂☂☂☂ (0)
- ☂☂☂☂☂ (0)
- ☂☂☂☂☂☂ (0)
- ☂☂☂☂☂☂☂ (0)
- ☂☂☂☂☂☂☂☂ (0)
- ☂☂☂☂☂☂☂☂☂ (0)
- ☂☂☂☂☂☂☂☂☂☂ (0)
- ♣♣♣♣♣♣♣♣♣♣ (0)
- ♣♣♣♣♣♣♣♣♣ (0)
- ♣♣♣♣♣♣♣♣ (0)
- ♣♣♣♣♣♣♣ (0)
- ♣♣♣♣♣♣ (0)
- ♣♣♣♣♣ (0)
- ♣♣♣♣ (0)
- ♣♣♣ (0)
- ♣♣ (0)
- ♣ (0)
- 【Android源码分析】✚ (4)
- 【Android项目阶段】✚ (1)
- ☞Android主流架构搭建 (0)
- ☞综合性<手机安全卫士> (0)
- ☞多媒体<手机影音> (1)
- ☞新闻性<北京新闻> (0)
- ☞社交性<硅谷社交> (0)
- ☞商城性<硅谷商城> (0)
- ☞内涵段子<百思> (0)
- ☞<地图相关开发接口> (0)
- ☞下载<电子应用市场> (0)
- ☞智能<手机遥控家电> (0)
- ☞游戏<植物大战僵尸> (0)
- ☞企业实战<开源中国> (0)
- ☞Android5.0+6.0新特性 (0)
- ☞高级特效专辑 (0)
- ☞项目管理与实施 (0)
- ☞项目经验:面试/笔试题 (0)
- 【Android 前沿技术】✚ (0)
- ☞图文混排技术 (0)
- ☞百分比布局 (0)
- H5混合开发☞ (0)
- ☞APP增量升级 (0)
- ☞软件崩溃收集 (0)
- ☞前沿技术分享 (0)
- 【Android+H5混合开发】✚ (0)
- ☞React基本语法 (0)
- ☞React Native开发环境搭建 (0)
- ☞React Native开发基础 (0)
- ☞React Native常用组件 (0)
- ☞React Native常用API (0)
- ☞豆瓣搜索项目 (0)
- ☏ (0)
- ☏☏ (0)
- ☏☏☏ (0)
- ☏☏☏☏ (0)
- ☏☏☏☏☏ (0)
- ☏☏☏☏☏☏ (0)
- ☏☏☏☏☏☏☏ (0)
- ☏☏☏☏☏☏☏☏ (0)
- ☏☏☏☏☏☏☏☏☏ (0)
- ☏☏☏☏☏☏☏☏☏☏ (0)
- ☎☎☎☎☎☎☎☎☎☎ (0)
- ☎☎☎☎☎☎☎☎☎ (0)
- ☎☎☎☎☎☎☎☎ (0)
- ☎☎☎☎☎☎☎ (0)
- ☎☎☎☎☎☎ (0)
- ☎☎☎☎☎ (0)
- ☎☎☎ (0)
- ☎☎ (0)
- ☎ (0)
- 【Android+H5项目实战】✚ (0)
- 【程序员软件系列】✚ (4)
- ☞Eclipse (0)
- ☞Android Studio (4)
- ☞Genymotion (0)
- ☞Tomcat服务器 (0)
- ☞MyScal (0)
- ☀ (0)
- ☀☀ (0)
- ☀☀☀ (0)
- ☀☀☀☀ (0)
- ☀☀☀☀☀ (0)
- ☀☀☀☀☀☀ (0)
- ☀☀☀☀☀☀☀ (0)
- ☀☀☀☀☀☀☀☀ (0)
- ☀☀☀☀☀☀☀☀☀ (0)
- ☀☀☀☀☀☀☀☀☀☀ (0)
- ☻☻☻☻☻☻☻☻☻☻ (0)
- ☻☻☻☻☻☻☻☻☻ (0)
- ☻☻☻☻☻☻☻☻ (0)
- ☻☻☻☻☻☻☻ (0)
- ☻☻☻☻☻☻ (0)
- ☻☻☻☻☻ (0)
- ☻☻☻☻ (0)
- ☻☻☻ (0)
- ☻☻ (0)
- ☻ (0)
- ♬♬♬ 技术网站 ♬♬♬ (2)
- ◙ (0)
- ◙◙ (0)
- ◙◙◙ (0)
- ◙◙◙◙ (0)
- ◙◙◙◙◙ (0)
- ◘◘◘◘◘ (0)
- ◘◘◘◘ (0)
- ◘◘◘ (0)
- ◘◘ (0)
- ◘ (0)
- 【Android 其他技术】✚ (0)
- ☞Android反编译 (0)
- ☞抓包 (0)
- ☞多渠道打包及软件上线 (0)
- 【github项目/博客系列】✚ (1)
- ☞注册github步骤 (0)
- ☞github项目 (0)
- ☞优秀博客系列 (1)
- 【开发经验分享】✚ (2)
- ☞Android 知识体系 (1)
- ☞项目经验分享 (0)
- ☞面试与就业指导 (1)
- ☞Android面试技术汇总 (2)
- ♬♬♬ 词汇 ♬♬♬ (0)
- 【Android基础单词】✚ (0)
- 【javaSE单词】✚ (0)
- 【个人博客资料】✚ (0)
- 博客链接 (1)
- 快速开发 (1)
- JavaEE面试题 (1)
最新评论
java基础集合框架——List、Set、Map概述(java集合一)
为什么会出现集合类?
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,出现集合
数组与集合同是容器,有什么不同呢?
数组长度是固定的,集合长度是可变的
数组中可以存储基本数据类型,集合只能存储对象
集合类的特点
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象
基本的集合框架如图
为什么会出现这么多的容器呢?
因为每一个容器对数据的存储方式都有不同,这个存储方式称为数据结构
集合框架分析
Collection子类
java.util.Collection [I] +--java.util.List [I] +--java.util.ArrayList [C] +--java.util.LinkedList [C] +--java.util.Vector [C] +--java.util.Stack [C]
Set子类
+--java.util.Set [I] +--java.util.HashSet [C] +--java.util.SortedSet [I] +--java.util.TreeSet [C]
Map集合及子类
java.util.Map [I] +--java.util.SortedMap [I] +--java.util.TreeMap [C] +--java.util.Hashtable [C] +--java.util.HashMap [C] +--java.util.LinkedHashMap [C] +--java.util.WeakHashMap [C]
表格分析
接口 | 实现类 | 历史实现类 |
List | ArrayList | Vector |
LinkedList | stack | |
Set | TreeSet | |
HashSet | ||
Map | HashMap | HashTable |
TreeMap | Properties |
List
List继承自Collection接口。List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组,List允许有重复元素
常用子类特点分析
Vector 内部是数组数据结构,是同步的,增删查询都很慢
ArrayList 内部是数组数据结构,是不同步的,查询速度快
LinkedList 内部是链表结构,是不同步的,增删元素很快
LinkedList
底层使用的链表数据结构,特点是:增删速度快,查询慢
LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:List list = Collections.synchronizedList(new LinkedList(...));LinkedList l = new LinkedList(); l.addFirst("java"); l.addFirst("java1"); l.addFirst("java2"); l.addFirst("java3"); * 在JDK1.6以后,出现的方法 * * offerFirst() * offerLast() * peekFirst() * peekLast() * 获取元素,但不删除元素,如果集合中没有元素,会出现null * pollFirst() * pollLast() * 获取元素,但是元素被删除,如果集合中没有元素,会出现nullArrayList
ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并 没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。和LinkedList一样,ArrayList也是非同步的(unsynchronized)。
底层使用的是数组结构,特点:查询速度很快,但是增删稍慢,默认长度是10;然后百分之50延长
ArrayList的常见操作
ArrayList arrayList = new ArrayList(); // 添加元素 arrayList.add("java1"); arrayList.add("java2"); arrayList.add("java3"); arrayList.add("java4"); //直接在控制台上输出集合中元素的信息 System.out.println(arrayList);// [java1, java2, java3, java4] // 在指定位置添加元素 arrayList.add(2, "world"); System.out.println(arrayList);// [java1, java2, world, java3, java4] // 删除指定位置的元素 arrayList.remove(2); System.out.println(arrayList);// [java1, java2, java3, java4] // 修改元素 arrayList.set(2, "java224"); System.out.println(arrayList);// [java1, java2, java224, java4] // 通过角标获取元素 System.out.println(arrayList.get(1));// java2 // 获取所有元素 //第一种方法 for (int i = 0; i < arrayList.size(); i++) { System.out.println(arrayList.get(i)); } //第二种方法 Iterator it = arrayList.iterator(); while (it.hasNext()) { System.out.println(it.next()); } // 通过indexOf获取对象的位置 System.out.println(arrayList.indexOf("java2")); // 获取指定区域的元素 List sb = arrayList.subList(1, 3);去除ArrayList中的重复元素
/** * 去除ArrayList中的重复元素 * @param l * @return */ private static ArrayList med8(ArrayList<Object> l) { ArrayList<Object> li = new ArrayList<Object>(); Iterator it = l.iterator(); while(it.hasNext()){ Object obj = it.next(); if(!li.contains(obj)){ li.add(obj); } } return li; }
对ArrayList中的数据进行排序的操作public static void main(String[] args) { //创建集合 ArrayList<String> arrayList = new ArrayList<String>(); //添加元素 arrayList.add("adsf"); arrayList.add("uytf"); arrayList.add("hjk"); arrayList.add("wedcv"); arrayList.add("kngfsf"); arrayList.add("wqqs"); //没有进行排序前 System.out.println(arrayList.toString());//[adsf, uytf, hjk, wedcv, kngfsf, wqqs] //对集合中的元素信息进行排序 Collections.sort(arrayList); System.out.println(arrayList.toString());//[adsf, hjk, kngfsf, uytf, wedcv, wqqs] //使用自定义比较器的方法,按照字符串的长度来进行排序 Collections.sort(arrayList,new StringSortComparator()); System.out.println(arrayList.toString());//[hjk, adsf, uytf, wqqs, wedcv, kngfsf] } } //自定义比较器,按照字符串的长度进行比较原则 class StringSortComparator implements Comparator<String>{ @Override public int compare(String arg0, String arg1) { //比较两个字符串的长度 int number = arg0.length()-arg1.length(); //==0说明两个字符串的长度一样,再进行内容比较 if(number==0){ return arg0.compareTo(arg1); } return number; } }listIterator List集合中特有的迭代器
在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificatinException异常
所以在使用迭代器的时候,只能用迭代器的方法操作元素,但是Iterator的方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作,如添加,修改等,就需要使用其接口,ListIterator
该接口只能通过List集合的listIterator方法获取
ArrayList<String> al = new ArrayList<String>(); ListIterator its= al.listIterator(); while(its.hasNext()) { String string = (String) its.next(); //its.hasNext()) 判断迭代指针后是否有元素 //its.hasPrevious() 判断迭代指针前是否有元素 } //以倒着取出元素 while(its.hasPrevious()) { String string = (String) its.previous(); }Vector
Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的 Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常
底层是数组数据结构,线程同步,被ArrayList替代了,长度为10,然后百分之百延长</pre><pre name="code" class="java">Vector<String> vector = new Vector<String>(); // 向集合中添加元素 vector.add("java"); vector.add("java1"); vector.add("java2"); vector.add("java3"); // 通过枚举的方式取出集合中的元素 Enumeration en = vector.elements(); while (en.hasMoreElements()) { String string = (String) en.nextElement(); } // 通过迭代器的方式取出数据 Iterator<String> iterator = vector.iterator(); while (iterator.hasNext()) { String string = iterator.next(); }Stack
Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方 法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈
Set
Set继承自Collection接口。Set是一种不能包含有重复元素的集合,Set最多有一个null元素。
在使用Set集合的时候,应该注意:1、为Set集合里的元素的实现类实现一个有效的equals(Object)方法。2、对Set的构造函数,传入的Collection参数不能包含重复的元素。
常见子类及特点:
HashSet 内部数据结构是哈希表,是不同步的。
TreeSet 可以对Set集合中的元素进行排序,是不同步的
HashSet
<1> 此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。它不保证集合的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
<2> HashSet不是同步的,需要用以下语句来进行S同步转换
- Sets=Collections.synchronizedSet(newHashSet(...));
<3> 是如何保证元素的唯一性?是通过元素的两个方法,hashCode和equals来完成,如果元素的HashCode值相同,才会判断equals来完成
如果元素的HashCode值不同,不会调用equals
<4> 对于判断元素是否还在,以及删除等操作,依赖的方法是元素的hashCode和equals方法
往HashSet集合中存入自定义对象
public class ListDemoClass { public static void main(String[] args) { //新建集合 HashSet hs = new HashSet(); //向集合中添加元素 hs.add("java2"); hs.add("java3"); hs.add("java1"); hs.add("java4"); hs.add("java5"); //注:add方法的返回值为boolean true代表添加元素成功 //使用迭代器的方法将集合中的元素数据取出 //获取迭代器 Iterator iterator = hs.iterator(); //取出数据 while(iterator.hasNext()){ Object next = iterator.next(); System.out.println("hs中的数据为 :"+next+""); } } }
往HashSet集合中存入自定义对象
定义要进行存储的对象类
public class PersonInfo { // 姓名和年龄相同为同一个人,重复元素 private String name; private int age; PersonInfo(String name, int age) { this.name = name; this.age = age; } public int hashCode() { return name.hashCode(); } public String getName() { return name; } public int getAge() { return age; } //进行比较的方法 public boolean equals(Object obj) { if (!(obj instanceof PersonInfo)) return false; PersonInfo pe = (PersonInfo) obj; return this.name.equals(pe.name) && this.age == pe.age; } }
编写储存数据的测试类
public class ListDemoClass { public static void main(String[] args) { // 往hAashSet集合中存入自定义对象 // 姓名和年龄相同为同一个人,重复元素 HashSet hs = new HashSet(); //向集合中添加元素 hs.add(new PersonInfo("lishi", 22)); hs.add(new PersonInfo("lishi1", 23)); hs.add(new PersonInfo("lishi2", 24)); hs.add(new PersonInfo("lishi3", 25)); hs.add(new PersonInfo("lishi3", 25)); hs.add(new PersonInfo("lishi3", 25)); Iterator it = hs.iterator(); while (it.hasNext()) { //取出集合中的元素 PersonInfo pe = (PersonInfo) it.next(); System.out.println( "person name is " + pe.getName()+"and age is "+pe.getAge()); } }编译运行调试
可以看到,我们向其中添加了六条数据,但实际上集合中只添加了四条数据,因为其中有两条数据是相同的,也就是说那两条数据与我们集合中现有的数据name 各age 是一致的TreeSet
<1> 可以对集合中的元素进行排序
<2> 里面存储的元素必须具有可比性
<3> TreeSet排序的第一种方式为 让元素自身具有比较性,元素需要实现compareable接口,覆盖compareTo方法,这种方式也是元素的自然顺序,或者叫默认顺序
向TreeSet中储存String类型的数据
public class ListDemoClass { public static void main(String[] args) { // 新建集合 TreeSet ts = new TreeSet(); //向集合中添加元素 ts.add("aaa"); ts.add("aoa"); ts.add("ara"); ts.add("aea"); //获取取迭代器 Iterator it = ts.iterator(); //循环取出集合中的元素,并将取出的元素输出在控制台上面 while (it.hasNext()) { System.out.println(it.next()); } }
可以看到,集合中储存的数据以按照其自然顺序进行了排序
//创建集合 TreeSet<String> treeSet = new TreeSet<String>(); //添加元素 treeSet.add("adsf"); treeSet.add("uytf"); treeSet.add("hjk"); treeSet.add("wedcv"); treeSet.add("kngfsf"); treeSet.add("wqqs"); //输出储存的数据 System.out.println(treeSet.toString());//[adsf, hjk, kngfsf, uytf, wedcv, wqqs]按照自定义的比较规则进行集合中元素排序
这里是按字符串的长度来进行排序
//将集合中的String类型的数据按照自定义的比较方法按长度由大到小进行排序 //创建集合 TreeSet<String> treeSet = new TreeSet<String>(Collections.reverseOrder(new StringSortComparator())); //添加元素 treeSet.add("adsf"); treeSet.add("uytf"); treeSet.add("hjk"); treeSet.add("wedcv"); treeSet.add("kngfsf"); treeSet.add("wqqs"); //输出储存的数据 System.out.println(treeSet.toString());//[kngfsf, wedcv, wqqs, uytf, adsf, hjk] //自定义比较器,按照字符串的长度进行比较原则 class StringSortComparator implements Comparator<String>{ @Override public int compare(String arg0, String arg1) { //比较两个字符串的长度 int number = arg0.length()-arg1.length(); //==0说明两个字符串的长度一样,再进行内容比较 if(number==0){ return arg0.compareTo(arg1); } return number; } }向TreeSet中储存自定义对象
在其中存储自定义对象的时候,必须使自定义对象具有可比性,那么可以实现 Comparable接口,然后复写compareTo方法,在其中定义比较对象顺序的方法发生
public class PersonBean implements Comparable { private String name; private int age; PersonBean(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public int compareTo(Object obj) { if (!(obj instanceof PersonBean)) throw new RuntimeException(); /** * 在这里定义比较对象大小的方法 * 先进行年龄的比较,年龄不相等再进行姓名的比较 * 如果年龄与姓名都相等,那么就代表同一个对象 */ PersonBean pe = (PersonBean) obj; if (this.age > pe.age) return 1; if (this.age == pe.age) { return this.name.compareTo(pe.name); } return -1; } }建立测试类
public class ListDemoClass { public static void main(String[] args) { // 向这个集合中存储自定义对象 TreeSet ts = new TreeSet(); ts.add(new PersonBean("lishi", 22)); ts.add(new PersonBean("lishi1", 23)); ts.add(new PersonBean("lishi3", 25)); ts.add(new PersonBean("lishi4", 25)); //获取迭代器,取出其中的元素 Iterator it = ts.iterator(); while (it.hasNext()) { PersonBean pe = (PersonBean) it.next(); System.out.println(pe.getAge() + " " + pe.getName()); } }可以看到输出的结果 ,先按照年龄进行排序储存,如果年龄相同,再按照姓名进行排序储存,如果姓名也相同,则代表是同一对象 ,则不进行储存
向TreeSet中传入比较器进行排序
这时需要让容器自身具备比较性,
那么需要定义比较器 ,将比较器对象作为参数传递给TreeSet 集合的构造函数
当两种排序都存在时,以比较器为主
那么可以定义一个类,实现Comparator接口,覆盖compare方法
新建储存对象,并实现Comparator接口,在compare方法中宝比较规则
public class PersonBean implements Comparable { private String name; private int age; PersonBean(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public int compareTo(Object obj) { if (!(obj instanceof PersonBean)) throw new RuntimeException(); /** * 在这里定义比较对象大小的方法 * 先进行年龄的比较,年龄不相等再进行姓名的比较 * 如果年龄与姓名都相等,那么就代表同一个对象 */ PersonBean pe = (PersonBean) obj; if (this.age > pe.age) return 1; if (this.age == pe.age) { return this.name.compareTo(pe.name); } return -1; } }
自定义一个比较器import java.util.Comparator; import java.util.HashSet; import java.util.Iterator; import java.util.TreeSet; class CustomCompare implements Comparator { public int compare(Object obj1, Object obj2) { //获取将要进行比较的两个对象 PersonBean p1 = (PersonBean) obj1; PersonBean p2 = (PersonBean) obj2; //先进行比较两个对象中的name是否相等,如果相等,那么将返回0 int num = p1.getName().compareTo(p2.getName()); //如果name相等,那么再比较age的大小 if (num == 0) { if (p1.getAge() > p2.getAge()) return 1; if (p1.getAge() == p2.getAge()) return 0; return -1; } return num; } }新建测试类:
public class ListDemoClass { public static void main(String[] args) { // 向这个集合中存储自定义对象 TreeSet ts = new TreeSet(new CustomCompare()); ts.add(new PersonBean("lishi", 22)); ts.add(new PersonBean("lishi1", 23)); ts.add(new PersonBean("lishi3", 25)); ts.add(new PersonBean("lishi3", 26)); ts.add(new PersonBean("lishi3", 24)); ts.add(new PersonBean("lishi4", 25)); // 取出集合中的元素数据,并将相关信息输出在控制台上 Iterator it = ts.iterator(); while (it.hasNext()) { PersonBean pe = (PersonBean) it.next(); System.out.println(pe.getAge() + " " + pe.getName()); } }
以字符串的长度为排序规则进对TreeSet集合中的String类型的数据进行排序
首先自定义一个比较器
class StringLengthCompare implements Comparator { public int compare(Object obj1, Object obj2) { //获取将要进行比较的字符串 String s = (String) obj1; String s1 = (String) obj2; int num = new Integer(s.length()).compareTo(new Integer(s1.length())); if (num == 0) { return s.compareTo(s1); } return num; } }新建测试类:
public class ListDemoClass { public static void main(String[] args) { // 按照字符长度排序 // 字符串具有比较性,但是不是所需要的 // 向这个集合中存储自定义对象 //新建TreeSet集合并将自定义比较 器传给集合 TreeSet ts = new TreeSet(new StringLengthCompare()); //向集合中添加不同长度的String字符串 ts.add("ggg"); ts.add("aaa"); ts.add("swed"); ts.add("asdfv"); ts.add("tyrfg"); //获取迭代器,循环取出集合中的数据并输出在控制台上 Iterator it = ts.iterator(); while (it.hasNext()) { String s = (String) it.next(); System.out.println(s); } }
Map
Map没有继承Collection接口。也就是说Map和Collection是2种不同的集合。Collection可以看作是(value)的集合,而Map可以看作是(key,value)的集合。Map接口由Map的内容提供3种类型的集合视图,一组key集合,一组value集合,或者一组key-value映射关系的集合。
常见子类及特点
HashTable 底层是哈希表,是同步的,null不可以做键值进行储存
HashMap 底层是哈希不结表结构,不同步,null可以做键值进行储存
TreeMap 底层是二叉树结构,是不同步的,Hashtable
Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCode和equals方 法。
特别说明
hashCode和equals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相 同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如 果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希 表的操作。
如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。Hashtable是同步的。HashMap
HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null ke
// 新建一个集合 Map<Integer, String> map = new HashMap<Integer, String>(); // 向map中添加10条数据 for (int i = 0; i < 10; i++) { map.put(i, "java" + i); } System.out.println(map);// {0=java0, 1=java1, 2=java2, 3=java3, ...} //删除指定位置的元素 map.remove(0); System.out.println(map);//{1=java1, 2=java2, 3=java3,...} //判断指定位置的元素是否在在 boolean containsKey = map.containsKey(0); System.out.println(containsKey);//false
取出map集合中的数据 方式一
//取出方式一 //获取集合中的元素 //先获取所有的key,然后再去获取所的value Set<Integer> keySet = map.keySet(); Iterator<Integer> iterator = keySet.iterator(); while (iterator.hasNext()) { //获取对应的key Integer next = iterator.next(); //根据key值获取对应的值 String string = map.get(next); }取出map集合中的数据 方式二
// 取出方式二 //将map中的键值的映射关系 作为对象储存到set集合中去 Set<Entry<Integer,String>> entrySet = map.entrySet(); //获取迭代器 Iterator<Entry<Integer, String>> iterator2 = entrySet.iterator(); while(iterator2.hasNext()){ Entry<Integer, String> entry = iterator2.next(); //获取key Integer key = entry.getKey(); //获取对应的value String value = entry.getValue(); }取出map集合中的数据 方式三
//取出方式三 Collection<String> values = map.values(); Iterator<String> iterator3 = values.iterator(); while(iterator3.hasNext()){ String valueString = iterator3.next(); }
TreeMap
创建一个类对象,作为key储存在TreeMap集合中class Person { //定义对象的两个私有属性 private String name = "张三"; private String age = "22"; private Person person; public Person() { super(); } public Person(String name, String age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public String getAge() { return age; }//创建一个集合 TreeMap<Person,String> treeMap = new TreeMap<Person,String>(); //向TreeMap中添加数据 treeMap.put(new Person("张三", "10"), "山西"); treeMap.put(new Person("李四", "15"), "上海"); treeMap.put(new Person("王五", "9"), "山西"); treeMap.put(new Person("小六", "13"), "北京"); //输出元素信息 System.out.println(treeMap);
编译运行;出现错误
- Exceptioninthread"main"java.lang.ClassCastException:Personcannotbecasttojava.lang.Comparable
- atjava.util.TreeMap.compare(UnknownSource)
- atjava.util.TreeMap.put(UnknownSource)
- atMapDemoTest.main(MapDemoTest.java:15)
走到这里,我们可以看到在进行元素储存的过程的时候就已经出现错误了
解决方案 (一)
使我们的对象本身具有比较性,实现Comparable接口,在compareTo方法定义比较规则为根据姓名来排序class Person implements Comparable<Person>{ //定义对象的两个私有属性 private String name = "张三"; private String age = "22"; private Person person; public Person() { super(); } public Person(String name, String age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public String getAge() { return age; } @Override public int compareTo(Person arg0) { return this.name.compareTo(arg0.name); }
这样后,我们再进行编译运行就要吧发现可以进行了
解决方案(二)
定义一个比较器,然后将比较器传给集合// 自定义一个比较器,在compare中定义比较规则 // 这里定义的比较规则是Person中的姓名进行比较 class MapSortCompar implements Comparator<Person> { @Override public int compare(Person o1, Person o2) { return o1.getName().compareTo(o2.getName()); } }
然后将比较器传递给集合// 创建一个集合 TreeMap<Person, String> treeMap = new TreeMap<Person, String>(new MapSortCompar()); // 向TreeMap中添加数据 treeMap.put(new Person("张三", "10"), "山西"); treeMap.put(new Person("李四", "15"), "上海"); treeMap.put(new Person("王五", "9"), "山西"); treeMap.put(new Person("小六", "13"), "北京"); // 输出元素信息 Set<Person> keySet = treeMap.keySet(); Iterator<Person> iterator = keySet.iterator(); while(iterator.hasNext()){ Person key = iterator.next(); String values = treeMap.get(key); System.out.println("key is "+key.getName()+"value is "+values); }编译运行:控制台会输出
- keyis小六valueis北京
- keyis张三valueis山西
- keyis李四valueis上海
- keyis王五valueis山西
集合中存储的都是对象的引用(地址);
什么是迭代器呢?
其实就是集合的取出元素的方式
把取出方式定义在集合的内部,这样取出方式就可 直接访问集合内容的元素
那么取出方式就被定义在成了内部类
而每一个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性内容---判断和取出,那么可以将写共性抽取,那么这些内部类都符合一个规则,该规则就是Iterator
如何获取集合的取出对象呢?
通过一个对外提供的方法
iterator()
相关推荐
### 精通Java集合框架——List, Set, Map #### 概述 Java集合框架是一种高度抽象且灵活的数据组织工具,它通过一系列接口来定义不同类型的数据容器,并提供了丰富的操作这些容器的方法。本文将深入探讨Java集合...
Java集合框架是Java编程语言中的核心部分,它提供了一种高效、灵活的数据存储和操作机制。本文将深入探讨集合框架的各个组成部分,包括Collection、List、Set和Map,以及它们的实现原理和排序方法。 1. **集合框架...
总之,Java集合框架是一个强大而灵活的数据结构库,通过理解并熟练运用其各种接口和类,开发者可以高效地管理和操作数据。无论是处理基本的数据存储需求,还是复杂的业务逻辑,Java集合框架都能提供合适的支持。
1. **理解Java集合框架的层次体系结构**:这涉及到集合接口与其实现类之间的关系,例如`Collection`接口与`List`、`Set`接口,以及具体的实现类如`ArrayList`、`LinkedList`、`HashSet`等。 2. **掌握List、Set、...
Java集合框架是Java编程语言中不可或缺的一部分,它提供了一种高效、灵活的数据组织方式,能够存储和管理不同类型的对象。本教程主要涵盖了Java基础入门的第7章——集合类,内容包括常用集合类、迭代器的使用、...
Java集合框架由一系列接口和实现这些接口的类组成,位于`java.util`包内。 **集合类的特点**: - 集合类用来存放对象,而不是基本数据类型。 - 集合类能够根据需要动态扩展其大小。 - 集合类支持多种不同的存储...
4. **集合框架**:Java集合框架包括List、Set、Map接口和它们的实现类。面试中可能会考察ArrayList、LinkedList、HashSet、HashMap的区别,以及如何选择合适的数据结构。 5. **内存管理与垃圾回收**:理解Java内存...
此外,课程还会涉及Java的标准库,它包含许多预先定义好的类和接口,如集合框架(List、Set、Map)、输入/输出流、线程管理和网络编程等。理解并熟练运用这些类库可以大大简化开发工作。 最后,课程可能会介绍如何...
通过本章的学习,读者应该能够理解Java集合框架的基本概念,并掌握如何使用`Arrays`类来进行数组的操作,如何使用`List`、`Set`和`Map`等接口和其实现类来高效地管理对象集合。这些技能对于Java软件开发来说至关重要...
集合框架 - **集合简介**:理解集合的概念及其在Java中的重要性。 - **List接口**:掌握ArrayList、LinkedList等实现List接口的类的特点和应用场景。 - **Set接口**:学习HashSet、TreeSet等实现Set接口的类的特性...
1. **接口层次**:在 Java Collection 框架中,主要有两大顶级接口——`Collection` 和 `Map`。 - `Collection` 接口主要处理单个对象的集合,而 `Map` 接口则用于处理键值对的形式。 - `Collection` 接口有两个子...
这部分内容更偏向于Java的高级特性,涵盖了异常处理、集合框架(List、Set、Map接口及其实现类)和IO流。异常处理是Java中处理错误和异常情况的关键机制,它能确保程序的健壮性。集合框架是存储和操作对象的主要工具...
- 集合框架:介绍Java集合框架的基本概念,包括List、Set、Map等接口及其实现类。 #### 尚硅谷Java基础实战——Bank项目 - **Bank项目概述**: - 项目背景:模拟一个简单的银行系统,包括账户管理、存款、取款等...
通过以上几个方面的介绍,我们可以看出《Java语言程序设计-基础篇》这本书覆盖了Java编程的基础知识点,从环境搭建到面向对象编程,再到异常处理和集合框架等方面都有涉及。对于初学者来说,系统地学习这些基础知识...
8. **集合框架**:Java集合框架包括接口(如List、Set、Map)和实现类(如ArrayList、LinkedList、HashSet、HashMap等),提供数据存储和操作的通用工具。 9. **输入/输出流**:Java的I/O流系统支持对文件、网络和...
4. **集合框架** - **List、Set、Queue**:了解ArrayList、LinkedList、HashSet、LinkedHashSet、LinkedList和PriorityQueue的基本特性和使用场景。 - **Map接口**:HashMap、TreeMap、ConcurrentHashMap及其各自...
- Java集合框架主要包括三种基本接口:`List`, `Set`, `Map`。 - `List` 和 `Set` 是`Collection`接口的子接口,而`Map`则是独立于`Collection`之外的另一种数据结构。 - **答案:** - `List` 和 `Set` 继承自`...
6. **集合框架**:介绍Java中的集合框架,如List、Set、Map等容器的使用方法。 7. **输入/输出(I/O)**:解释Java中的文件读写操作以及网络编程基础。 8. **多线程编程**:讨论Java中的线程管理机制,包括线程创建、...
### Java基础面试宝典——集合篇 ...通过以上内容的学习,你可以更好地理解Java集合框架的基本概念、特点以及如何在实际开发中合理选择和使用各种集合类型。希望这些知识能够帮助你在接下来的面试中取得好成绩!