Java 类集初探
类集
- 类集:主要功能就是java数据结构的实现(java.util)
- 类集就是动态对象数组(链表也是动态数组)
collection 接口*
- collection是整个类集之中单值保存的最大 父接口 。即:每一次仅可以向集合中保存一个对象
public interface collection<e> extends iterable<e>
- 在collection定义的常用操作方法
常用操作方法
- 向集合中保存数据
public boolean add(e e);
- 追加一个集合
public boolean addall(collection<? extends e>c);
- 清空集合(根元素为null)
public void clear();
- 判断是否有指定的内容
public boolean contains(object o);
- 判断是否为空集合
public boolean isempty();
- 删除对象
public boolean remove(object o);
- 取得元素个数
public int size();
- 以对象数组保存集合
public object [] toarray();
- 为iterator接口实例化
public iterator<e> iterator();
contains() 和 remove() 一定要依靠 equals() 的支持;
list子接口
- list子接口是collection接口中最常用的子接口;
- list对collection接口进行了功能的扩充;
常用操作
- 取得索引编号的内容
public e get(int index);
- 修改索引的内容
public e set(int index , e element);
- 为lisiterator接口实例化对象
public listiterator<e> listiterator();
list属于接口,如果想使用接口进行操作,就必须存在子类;使用 arraylist 子类实现(和vector子类)
arraylist子类
public static void main(string [] args) throws ioexception { list<string> all = new arraylist<string>(); system.out.println("size:" + all.size() + "null:" + all.isempty()); all.add("hello"); all.add("hello"); all.add("world"); system.out.println("size:" + all.size() + "null:" + all.isempty()); // collection接口定义了size()方法取得集合长度 // list子接口增加了 get() 方法,可取取得所有的数据 for (int x = 0 ; x < all.size() ; x++) { string str = all.get(x); system.out.println(str); } } }
通过对arraylist()子类的使用分析在:list集合中所保存的数据是按照保存的顺序存放的,而且允许重复数据;list子接口有get()方法,可以获得集合中指定序列的内容
- 为collection接口实例化
public class testdemo { public static void main(string [] args) throws ioexception { collection<string> all = new arraylist<string>(); system.out.println("size:" + all.size() + "null:" + all.isempty()); all.add("hello"); all.add("hello"); all.add("world"); system.out.println("size:" + all.size() + "null:" + all.isempty()); object[] obj = all.toarray();//变为对象数组读取数据 for (int x = 0 ; x < obj.length ; x ++) { system.out.println(obj[x].tostring()); } /*for (int x = 0 ; x < all.size() ; x++) { string str = all.get(x);// 由于collection类中没有get()方法所以无法使用 system.out.println(str); }*/ } }
- list保存对象
class book { private string title ; private double price ; public book(string title , double price) { this.price = price; this.title = title; } @override public boolean equals(object obj) { if (this == obj) { return true ; } if (obj == null) { return false; } if(!(obj instanceof book)) { return false ; } book book = (book) obj; if (this.title.equals(book.title) && this.price == book.price){ return true; } return false; } @override public string tostring() { return this.title + "\t" + this.price + "\n"; } } public class testdemo { public static void main(string [] args) { list<book> all = new arraylist<book>(); all.add(new book("java",11.1)); all.add(new book("python",22.2)); all.add(new book("c/c++",33.3)); all.add(new book("php",44.4)); // 切记:remove和contains方法需要在类中覆写equls()类 all.remove(new book("php",44.4)); system.out.println(all); } }
vector子类(旧)
-
区别:
vector子类采用同步处理,线程安全;而arraylist子类则采用非线程安全的异步处理机制。arraylist支持iterator、listiterator、foreach输出,而vector还支持enumeration。
总结:
- list中的数据保存顺序就是数据的添加顺序
- list集合中允许保存有重复的元素
- list子接口比collection扩充了get()、set()方法
- list大多使用arraylist子类进行操作
set 子接口
set子接口只是简单点额继承了collection接口,并没有效仿list接口对原接口的功能方法进行扩充。
常见子类:hashset、treeset
观察 hashset 子类:
public class testdemo { public static void main(string [] args) { set<string> all = new hashset<string>(); all.add("hello"); all.add("hello");//不保存重复的数据 all.add("world"); all.add("huawei"); system.out.println(all + ">>>" + all.size()); } }
通过观察发现:set集合下没有重复的数据元素(set 子接口的特征)即:hashset 子类特征属于 无序排列
- 观察 treeset子类:
public class testdemo { public static void main(string [] args) { set<string> all = new treeset<string>(); all.add("hello"); all.add("hello");//不保存重复的数据 all.add("world"); all.add("array"); system.out.println(all + ">>>" + all.size()); } }
分析得出:treeset子类没有重复数据,以及所保存的内容默认自动升序排序。
数据排序问题
class book implements comparable<book>{ private string title ; private double price ; public book(string title , double price) { this.title = title; this.price = price; } @override public string tostring() { return this.title + "\t" + this.price; } /* * 集合本质上就是动态对象数组,而动态的对象数组排序使用的是比较器 * 所以我们使用comparable比较器 * * 由于存在重复的元素,compareto会认为是同一个对象,(set子接口的特性) * 所以 set子接口的重复判读就是依靠comparable * 为此我们可以使用string的compareto方法进行同对象的比较 */ @override public int compareto(book o) { if (this.price > o.price) { return 1; } else if(this.price < o.price) { return -1; } else { // 我们调用string类的compareto方法来比较 return this.title.compareto(o.title); } } } public class testdemo { public static void main(string [] args) { set<book> all = new treeset<book>(); all.add(new book("java",11.1)); all.add(new book("java",11.1)); //信息完全重复 all.add(new book("php",11.1)); //信息部分重复 all.add(new book("python",33.3)); //信息完全不重复 system.out.println(all); } }
通过观察发现,comparable接口支持了treeset类的重复数据的判断,并不支持对hashset类的重复数据的判读
重复元素问题
通过上述的各段代码发现:comparable接口(比较器)只负责对treeset子类的重复元素的判断;(依靠comparto()方法,如若发现数据相同则判断为是同样的对象元素,则 return 0;)
如果要判断数据元素的重复,只能依靠object中的方法:
- 取得哈希码
public int hashcode();
- 对象比较
public boolean equals(object obj);
代码:
@override public int hashcode() { final int prime = 31; int result = 1; long temp; temp = double.doubletolongbits(price); result = prime * result + (int) (temp ^ (temp >>> 32)); result = prime * result + ((title == null) ? 0 : title.hashcode()); return result; } @override public boolean equals(object obj) { if (this == obj) return true; if (obj == null) return false; if (getclass() != obj.getclass()) return false; book other = (book) obj; if (double.doubletolongbits(price) != double.doubletolongbits(other.price)) return false; if (title == null) { if (other.title != null) return false; } else if (!title.equals(other.title)) return false; return true; }
-
总结:
在不考虑排序问题情况下,判断元素是否重复,依靠object方法中的 hashcode() 和 equals()
总结:
- 在开发中,set子接口不建议首选,如果使用也是首选建议hashset类;
- comparable 比较器普遍应用于java理论中
集合输出
collection、list、set三个接口,list接口是最有利于输出操作的(arraylist子类),故此集合的输出:
iterator*:迭代输出
public interface iterator<e> { public boolean hasnext(); public e next<e>(); }
iterator是一个接口,如若取得接口的实例化需要依靠collection接口iterator()方法
public iterator<e> iterator();// java.util.collection
public class testdemo { public static void main(string [] args) { set<string> all = new hashset<string>();//set子接口 all.add("mirror"); all.add("wangyuyang"); all.add("wangyuyang"); iterator<string> iter = all.iterator();// 实例化接口 while (iter.hasnext()) { //判断是否为空 string str = iter.next();// 获取元素数据 system.out.println(str); } } }
set的特性会自动不保留重复数据,并无序输出
public class testdemo { public static void main(string [] args) { list<string> all = new arraylist<string>();//list子接口 all.add("mirror"); all.add("wangyuyang"); all.add("wangyuyang"); iterator<string> iter = all.iterator();// 实例化接口 while (iter.hasnext()) { //判断是否为空 string str = iter.next();// 获取元素数据 system.out.println(str); } } }
显示添加的所有元素并原样添加的顺序输出
-
集合的输出问题:
在遇到集合的输出问题是,完全可以直接使用iterator接口进行输出
listiterator:双向迭代
iterator本身只具备”由前向后“的输出,而 listlterator 子接口则支持双向迭代。
判断是否有前一个元素:(逆向)
public boolean haspreviout();
- 取得前一个元素:(逆向)
public e previous();
- 实例listiterator接口的list方法:
public listiterator<e> listiterator();
public class testdemo { public static void main(string [] args) { list<string> all = new arraylist<string>();//set子接口 all.add("a"); all.add("b"); all.add("c"); system.out.println("正向迭代输出"); listiterator<string> iter = all.listiterator(); while (iter.hasnext()) { //判断是否为空 string str = iter.next();// 获取元素数据 system.out.println(str); } system.out.println("***********"); system.out.println("逆向迭代输出"); while(iter.hasprevious()) { system.out.println(iter.previous()); } } }
上例程序实现了双向迭代的功能;利用hasnet()方法判断是否为空,next()方法输出元素内容,实现正向迭代输出;利用listiterator接口中的hasprevious()和previous()方法来实现逆向迭代输出。
- 注意:
如果利用listiterator接口实现逆向迭代输出,就需要先进行正向迭代输出;也就是说在实现逆向迭代输出前必须实现正向迭代输出。
enumeration:枚举输出
enumeration 和 vector类同时发布的输出接口;早期的vector类定义的集合就需要enumeration 来输出。
- 接口定义
public interface enumberation<e>{ public boolean hasmoreelements(); //判断是否有下一个元素 public e nextelement(); // 获取当前元素内容 }
- 实例化 enumeration接口对象,只能依靠 vector子类
public enumeration<e> elements() // 取得enumeration接口对象
public class testdemo { public static void main(string [] args) { vector<string> all = new vector<string>();//set子接口 all.add("a"); all.add("b"); all.add("c"); enumeration<string> enu = all.elements(); while(enu.hasmoreelements()) { system.out.println(new string(enu.nextelement())); } } }
foreach 输出
public class testdemo { public static void main(string [] args) { list<string> all = new arraylist<string>();//set子接口 all.add("a"); all.add("b"); all.add("c"); for (string str : all) { system.out.println(str); } } }
map接口
collection每次都会保存一个对象,而map接口主要负责一对对象的信息。
主要操作方法
- 向集合中保存数据
public v put(k key , v value);
- 根据key查找value
public v get(object key);
- 将map结合转化为set集合
public set<map entry<k,v>> entryset();
- 取出所有key值
public set<k> keyset();
- 常用子类:
- hashmap
- hashtable
观察hashmap
public class testdemo { public static void main(string [] args) { map<string,integer> map = new hashmap<string,integer>(); map.put("壹", 1); map.put("贰", 2); map.put("叁", 3); map.put("叁", 33); system.out.println(map); } }
通过代码分析可以发现:hashmap实现的输出是无序的;发现的重复的key会进行覆盖,使用新的内容key的value覆盖原来的value
- get方法的应用
public class testdemo { public static void main(string [] args) { map<string,integer> map = new hashmap<string,integer>(); map.put("壹", 1); map.put("贰", 2); map.put(null, 3); system.out.println(map.get("壹")); //返回 1 system.out.println(map.get("陸"));//key不存在返回 null system.out.println(map.get(null));// 返回 3 } }
通过hashmap和get()方法的代码观察发现,map主要的目的是实现数据的信息的查找,collection主要的目的是实现信息数据的输出。
- 取得所有的key值:
public class testdemo { public static void main(string [] args) { map<string,integer> map = new hashmap<string,integer>(); map.put("壹", 1); map.put("贰", 2); map.put("叁", 3); set<string> set = map.keyset();// 取得key iterator<string> iter = set.iterator(); while(iter.hasnext()) { system.out.println(iter.next());//输出全部的key } } }
观察hashtable
public class testdemo { public static void main(string [] args) { map<string,integer> map = new hashtable<string, integer>(); map.put("壹", 1); map.put("贰", 2); map.put("叁", 3); system.out.println(map); } }
通过设置key或value为null值来比较hashtable和hashmap两个子类之间区别:hashtable子类不允许存在null值,而hashmap允许key或value中为null值。*
iterator输出的问题(重点)
涉及到集合的输出,一定要使用iterator进行输出;而map接口中未定义返回iterator接口对象的方法,故此map数据使用iterator输出就需要将map集合转换为set集合。
在collection接口中,iterator得到的是一个collection完整的对象;而map则不同了,但是map.put()向集合中存一对数据的时候,会自动的封装为map.entry接口对象
public static interface map.entry<k,v>;//(等同于一个外部接口)
- map.entry接口操作方法
- getkey():获取key值
- getvalue():获取value值
在map中保存的实际上是被map.entry接口包装的一个对象,map.entry接口的对象包装的是:key和value值对数据元素。
- 如上述,iterator如取出输出的数据实取得是一个对象(collection接口中就是实质上取得collection的对象),而在map接口中,则是取出一个map.entry接口对象,然后在得出key和value。
- 在map定义了一种将map集合转为set的方法:
public set<map.entry<k,v>> entryset();
转为set集合后,就可以调用iterator输出。
利用map接口entryset()方法将map结合变为set集合 ——> 利用set结合中的iterator()方法将set进行iterator输出 ——> 每一次取出的set元素都是map.entrty接口对象,利用此对象进行key与value的取出
利用iterator实现map接口的输出 *
public class testdemo { public static void main(string [] args) { map<string,integer> map = new hashtable<string, integer>(); map.put("壹", 1); map.put("贰", 2); map.put("叁", 3); // 将map集合变为set结合 set<map.entry<string, integer>> set = map.entryset(); // 将set集合实例化iterator接口对象 iterator<map.entry<string, integer>> iter = set.iterator(); while(iter.hasnext()) { // 因为iter内容保存的是map.entry接口的对象,所以利用map.entry对象将key和value取出 map.entry<string, integer> men = iter.next(); system.out.println(men.getkey() + "==" + men.getvalue()); } } }
map集合中的key
使用的map集合,key的类型可以自定义;那么这个自定义的类型必须覆写object类之中的hashcode() 和 equals()方法,因为只有依靠这两个方法,才可以判断是否元素重复。【首先的key类型是string,尽量不要使用自定义的对象类型去定义key;因为string类中默认了hashcode() 和 equals()】
class book{ private string title ; public book(string title) { this.title = title; } @override public string tostring() { return this.title; } @override public int hashcode() { final int prime = 31; int result = 1; result = prime * result + ((title == null) ? 0 : title.hashcode()); return result; } @override public boolean equals(object obj) { if (this == obj) return true; if (obj == null) return false; if (getclass() != obj.getclass()) return false; book other = (book) obj; if (title == null) { if (other.title != null) return false; } else if (!title.equals(other.title)) return false; return true; } } public class testdemo { public static void main(string [] args) { map<book,string> map = new hashmap<book, string>(); map.put(new book("java"),new string ("开发")); system.out.println(map.get(new book("java"))); } }
或者:
public class testdemo { public static void main(string [] args) { map<string,book> map = new hashmap<string, book>(); map.put(new string ("开发"),new book("java")); system.out.println(map.get(new string("开发"))); } }
public class testdemo { public static void main(string [] args) { map<string,book> map = new hashmap<string, book>(); map.put("开发",new book("java")); system.out.println(map.get("开发")); } }
总结
- map集合保存数据更有利与查找,而collection保存数据是为了输出
- map使用iterator接口输出步骤:……
- hashmap可以保存null,hashtable不可以保存null。
- 可以不可以重复,一旦出现重复会覆盖原有内容(更新key的value值)
stack子类
stack 表示:栈操作;栈是一种先进后出的数据结构;而stack是vector的子类。
public class stack<e> extends vector<e>
需要注意:stack虽是vector子类,可是不会使用vector方法。
stack栈操作:
- 入栈:
public e push(e item);
- 出栈:
public e pop();
- 实现入栈、出栈操作
public class testdemo { public static void main(string [] args) { stack<string> all = new stack<string>(); all.push("a"); all.push("b"); all.push("c"); all.push("d"); system.out.println(all.pop()); system.out.println(all.pop()); system.out.println(all.pop()); system.out.println(all.pop()); } }
如果栈中数据已经全部执行出栈而依旧继续执行出栈pop操作,则报错:空栈异常(栈中无数据则无法出栈执行操作)
properties子类
collections工具类
- 向集合中追加一组数据
public static <t> boolean addall(collection<e> c,……);
public class testdemo { public static void main(string [] args) { list<string> all = new arraylist<string>(); collections.addall(all, "a","b","c","d"); system.out.println(all); } }
collections工具类是负责给集合操作接口collection提供辅助的操作方法
下一篇: 深入学习SpringMVC