JAVA 集合总结+DEMO

原创 2016年08月30日 10:15:26
/*Collection 接口中有两个常用的子接口:List(列表),Set(集)。

*List:元素存取是有序的,可存放重复元素。
                 ArrayList:底层为数组结构。查询速度快。增删稍慢。线程不同步。
                 LinkedList:底层为链表结构。增删速度快,查询稍慢。线程不同步。有更丰富的头尾操作。
                 Vector:底层为数组结构。线程同步。被ArrayList替代了。因为效率低。

*Set:元素存取是无序的,不可以存放重复元素。
                HashSet:HashSet:数据结构是Hash表,线程是非同步的。
    保证元素的唯一性原理:判断元素的HashCode是否相同,如果相同,还会继续判断元素的equals方法,是否为true。

                TreeSet:数据结构为二叉树,线程不同步。

  可以对Set集合中的元素进行排序

                                  实现Comparable接口,重写compareTo(Object obj)方法或

  实现Comparator接口,重写compare(Object o1,Object o2)方法

*Map:存储键值对,键不可以重复,值可以重复。
                取出map集合元素的两种方式方法keySet()和entrySet()。
                HashMap:数据结构为哈希表,允许使用 null 值和 null 键,线程不同步。
                Hashtable:数据结构为哈希表,不可以存入null键null值,线程同步。
                TreeMap:数据结构为二叉树。线程不同步。
                              用于给map集合中的键进行排序(排序方法和TreeSet一样,实现comparable 或 comparator 接口即可)。

* 注:其实Set底层就是使用了Map集合

*/


public class JavaBase_Collection {

/*
* List:元素可以重复,有序 
* ArrayList:结构(数组列表),底层代码操作的就是数组。 非实现 synchronized 线程同步,是非线程安全的。
* Vector:实现了 synchronized 线程同步,是线程安全的 。
* LinkedList: 结构(链表结构)有更丰富的头尾操作。
*/


@Test
public void ArrayListTest() {
List<String> list = new ArrayList<String>();
list.add(0, "aa");
list.add(0, "bb");
list.add("cc");
System.out.println("重复下标插入会当前下标的元素往后面移动,所以现在的元素大小为:" + list.size());


// 遍历方式
System.out.println(" for 下标循环");
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
System.out.println("\n forEach 遍历");
for (String str : list) {
System.out.print(str);
}
System.out.println("\n Itorator 迭代器遍历");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.print(it.next());
}


// contains 只判断是否存在指定的值,
// 如果一个拿一个相同的对象来进行比较, 则需要在改对象类内重写 equals
// 方法(可选择类中的某个属性作为重写equals的条件,比如ID)
person p = new person();
p.setAge(20);
p.setName("afen");
person p1 = new person();
p1.setAge(20);
p1.setName("afen");
List<person> lp = new ArrayList<person>();
lp.add(p);
System.out.println("\n" + lp.contains(p1));


// remove 的返回值就是被移除的对象
String str = list.remove(0);
System.out.println("我是被 remove 掉的对象:" + str);
}


/*
* Vector 底层也是数组的操作大部分功能和 ArrayList 一样; 区别 Vector 底层代码实现了 synchronized
* 所以是线程安全的,而 ArrayList 则是非线程安全的。
*/
@Test
public void vactorTest() {
Vector<String> v = new Vector<String>();
v.add("aa");
v.add("bb");
// 遍历方式除了for,forEach,Iterator 之外,还有一种老版本的方式
Enumeration<String> e = v.elements();
while (e.hasMoreElements()) {
System.out.println(e.nextElement());
}
}


/*
* LinkedList 和  ArrayList 使用基本类似 LinkedList 有更丰富的头尾操作 
* 底层数据结构是 链表结构
*/
@Test
public void LinkedListTest() {
LinkedList<String> linkList = new LinkedList<String>();
linkList.add("bbb");
linkList.addLast("ccc");
linkList.addFirst("aaa");
System.out.println(linkList);
}


/*
* Set:无序,不可重复元素\
* HashSet:数据结构是Hash表,线程是非同步的。
* 保证元素的唯一性原理:判断元素的HashCode是否相同,如果相同,还会继续判断元素的equals方法,是否为true。

* TreeSet:底层数据结构是二叉树。 可以对Set中的元素进行排序,对象排序需要 实现Comparable,或者 Comparator 接口
* 保证元素唯一性依据:compareTo 方法 return 0。
*/


/*
* HashSet 主要的特点是:里面不能存放重复元素,而且采用散列的存储方法,所以没有顺序。
*/
@Test
public void hashSetTest() {
Set<String> set = new HashSet<String>();
set.add("b");
set.add("c");
set.add("d");
set.add("b");
set.remove("b");


Iterator<String> it = set.iterator();
while (it.hasNext()) {
String value = it.next();
System.out.println(value);
}
// 使用For Each输出结合
for (String e : set) {
System.out.print(e + " ");
}
}


/*
* TreeSet 可以对Set中的元素进行排序。 底层数据结构是二叉树。 保证元素唯一性依据:compareTo 方法 return 0。
* 存入的元素必须要保证具备排序比较性: 
* 1. 让元素自身具备比较性{ 如果是存放对象, 如果对象没有实现结构 Comparable
* 则会报异常(java.lang.Comparable), 如果需要使用存入对象并排序, 则需要在对象类 实现 Comparable,
* 让对象具备比较性, 并可在重写 compareTo 方法内自定义业务逻辑得到返回值,实现排序。 按照存入顺序的倒序排序: compareTo
* 方法直接返回 -1 按照存入顺序的升序排序:compareTo 方法直接返回 1 } 
* 2. 让容器自身具备比较性{
* 自定义一个类,实现Comparator 接口,重写 compare 方法 按照存入顺序的倒序排序: compare 方法直接返回 -1
* 按照存入顺序的升序排序:compare 方法直接返回 1 } 
* 注意: 如果元素连两个比较性都存在, 则优先 容器比较器
*/
@Test
public void TreeSetTest() {
// 普通排序
Set<String> set = new TreeSet<String>();
set.add("cc");
set.add("bb");
set.add("aa");
System.out.println(set);


// 对象排序,需要在对象内部实现 Comparable 接口,并重写compareTo 方法自定义业务逻辑得到返回值,实现排序
Set<student> set1 = new TreeSet<student>();
set1.add(new student("afen3", 38));
set1.add(new student("afen1", 48));
set1.add(new student("afen2", 38));
for (student s : set1) {
System.out.println("NAME=" + s.getName() + " -- age=" + s.getAge());
}


System.out.println("====================================");
// 容器排序,需要自定义一个排序类,实现 Comparator 接口,并重写compare 方法自定义业务逻辑得到返回值,实现排序
Set<student> set2 = new TreeSet<student>(new myCompara());
set2.add(new student("afen3", 38));
set2.add(new student("afen1", 48));
set2.add(new student("afen2", 38));
set2.add(new student("afen3", 28));
for (student s : set2) {
System.out.println("NAME=" + s.getName() + " -- age=" + s.getAge());
}
System.out.println("====================================");
// 按照字符串长度排序
Set<String> set3 = new TreeSet<String>(new stringComparator());
set3.add("bb");
set3.add("aa");
set3.add("cccc");
set3.add("ddd");
System.out.println(set3);
}


/*
* Map 
* HashTable :底层是哈希表数据结构,不可以存入 Null建 Nuull值,该集合是线程同步的。
* HashMap :底层是哈希表数据结构,可以存入 Null建 Nuull值,该集合是非线程同步的。
* TreeMap :底层是二叉树数据结构,可以对Map集合中的建进行排序,该集合是非线程同步的。
*/
@Test
public void mapTest(){
Map<String, String> map=new HashMap<String, String>();
map.put("01", "afen");
map.put("02", "xiaofen");
map.put(null, "lisi");
map.put("03", null);
System.out.println("containsKey:"+map.containsKey("01")+", containsValue:"+map.containsValue("afen"));

/* keySet : 获得到Map集合中的所有键形成 Set 集合,因为Set具有迭代器,所以可以通过迭代器遍历出所有的Key,
Map 再通过get获取到对应的值。
*/
Set<String> set=map.keySet();
Iterator<String> it=set.iterator();
while (it.hasNext()) {
String key=it.next();
String value=map.get(key);
System.out.println("key="+key+",value="+value);
}
/*
*  entrySet : 将Map集合的映射关系取出,存入到 Set 集合中
*/
System.out.println("=======================");
Set<Map.Entry<String, String>> set1=map.entrySet();
Iterator<Map.Entry<String, String>> it1=set1.iterator();
while(it1.hasNext()){
Map.Entry<String, String> entry=it1.next();
System.out.println("key="+entry.getKey()+",value="+entry.getValue());
}
/*
* Map 存入对象作为键,需要在对象的内部类重写 HashCode 和 equals 方法, 否则 Map 就会存入相同键的对象
*/
Map<teacher,String> map1=new HashMap<teacher,String>();
map1.put(new teacher("lisi1",30), "beijin");
map1.put(new teacher("lisi2",32), "tianjin");
map1.put(new teacher("lisi3",33), "nanjin");
map1.put(new teacher("lisi3",33), "nanjin");
Iterator<teacher> iter=map1.keySet().iterator();
while (iter.hasNext()) {
teacher t=iter.next();
String value=map1.get(t);
System.out.println("teacher..."+t+", value..."+value);
}
/*
* TreeMap 底层是二叉树数据结构,可以通过key 来排序
*   如果要实现对象排序,和TreeSet一样也要实现 comparator或者comparable 接口
*/
Map<teacher,String> map2=new TreeMap<teacher,String>();
map2.put(new teacher("lisi1",40), "beijin");
map2.put(new teacher("lisi2",30), "tianjin");
map2.put(new teacher("lisi3",20), "nanjin");
map2.put(new teacher("lisi3",20), "nanjin");
Set<Map.Entry<teacher,String>> entry1= map2.entrySet();
Iterator<Map.Entry<teacher,String>> iter1=entry1.iterator();
while (iter1.hasNext()) {
Map.Entry<teacher, String> entry=iter1.next();
System.out.println("teacher:"+entry.getKey()+", adrr:"+entry.getValue());
}
System.out.println("=======================================");
Map<teacher,String> map3=new TreeMap<teacher,String>(new teacherComparator());
map3.put(new teacher("lisi1",40), "beijin");
map3.put(new teacher("lisi2",30), "tianjin");
map3.put(new teacher("lisi3",20), "nanjin");
map3.put(new teacher("lisi3",20), "nanjin");
Set<Map.Entry<teacher,String>> entry2= map3.entrySet();
Iterator<Map.Entry<teacher,String>> iter2=entry2.iterator();
while (iter2.hasNext()) {
Map.Entry<teacher, String> entry=iter2.next();
System.out.println("teacher:"+entry.getKey()+", adrr:"+entry.getValue());
}
}

/*
* Map 练习
* 获取字符串字符出现的字数 以 a(3), b(4) 事列显示
*/
@Test
public void pringCharCount(){
Set<Map.Entry<Character, Integer>> set=this.charCount("abcdefabaacf").entrySet();
Iterator<Map.Entry<Character, Integer>> it=set.iterator();
while(it.hasNext()){
Map.Entry<Character, Integer> entry=it.next();
System.out.println(entry.getKey()+"("+entry.getValue()+") ");
}
}

public Map<Character,Integer> charCount(String str){
char[] c=str.toCharArray();
Map<Character,Integer> map=new TreeMap<Character,Integer>();
for (int i = 0; i < c.length; i++) {
int num=map.get(c[i])==null?1:map.get(c[i])+1;
map.put(c[i], num);
}
return map;
}


@Test
public void ArrayListToString() {
ArrayList<String> als = new ArrayList<String>();
als.add("aa");
als.add("bb");
String[] s = (String[]) als.toArray(new String[0]);
System.out.println(s[1]);
}


@Test
public void ListToString() {
List<String> list = new ArrayList<String>();
list.add("aa");
list.add("bb");
String[] strArr = new String[list.size()];
strArr = list.toArray(strArr);
System.out.println(strArr[1]);
}
}

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

JavaWeb入门经典实例

综述:这篇文章主要从一个小小的实例出发,对JavaWeb的开发做入门讲解,非常适合初学JavaWeb的人,入门者可飘过。       实例开发技术包括jsp、jstl、servlet、javabea...

JAVA入门基础知识小结

从C++到Java入门基础知识小结...

java集合框架代码演示demo

这里的代码演示可以结合前面写的关于集合的文章;原本是想分别对应把代码放到相应的地方的,恩,由于我有点懒,就直接放在这儿了。 Student类:package zyf.com;import java....

Java 集合 4:TreeMap 的使用(不包括原理,仅仅是简单的使用 demo)

我们知道,HashMap 放入的 Entry 是没有顺序的,而 LinkedHashMap 是根据 put 的顺序或者是访问的顺序来排序,而不是根据 key 的大小来排序。那么 TreeMap 就有这...

java集合框架的实现类的一些示例demo

对于java集合框架的实现类的一些示例demo。import java.math.BigDecimal; import java.text.DecimalFormat; import java.uti...
  • JQ_AK47
  • JQ_AK47
  • 2016年10月17日 22:03
  • 1247

排序算法总结 实现 Demo (Java)

  • 2016年05月19日 17:53
  • 102KB
  • 下载

菜鸟学Java(一)——Ajax异步检查用户名是否存在(附Demo下载)

在任何网站注册用户的时候,都会检查用户是否已经存在。很久以前的处理方式是将所有数据提交到服务器端进行验证,很显然这种方式的用户体验很不好;后来有了Ajax,有了异步交互,当用户输完用户名继续填写其他信...

微信支付 java 服务端demo (v3版本app支付 springMVC框架中)

由于微信官方没有app支付后台demo,前天公司要对接微信支付,经过这两天在网上找的资料以及结合官方文档,今天开发和测试终于顺利收尾,本篇文章仅包含微信app支付v3版本 java后台代码片段,and...

Akka 实践(二)- java开发demo1

Akka 的java 开发
  • csolo
  • csolo
  • 2016年10月24日 22:31
  • 1521
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA 集合总结+DEMO
举报原因:
原因补充:

(最多只允许输入30个字)