传智播客-Java集合框架-day06

---------------------- android培训、java培训、期待与您交流！ ----------------------

------1401------导包import java.util.*;
数组与集合的不同：
数组是固定长度，只能存同一类型
集合是可变长度，可以存不同类型

Collection集合
每个窗口对数据的存储方式都有不同，这个存储方式称之为数据结构。

------1402
1.add方法的参数类型是Object，以便于接收任意类型对象。
2.集合中存储的都是对象的引用(地址)
直接打印集合
例：System.out.println(集合);
可以输出集合的值。

A.retainAll(B)取交集，A中只保留AB中相同的元素。
------1403
迭代器(Iterator)：其实就是集合取出元素的方式。

------1404
Arraylist获取元素方法：
1.ArrayList获取所有元素：
 用for(int x=0;x<al.size();x++)   遍历所有元素
2.用迭代器(ITerator)获取所有元素：
 ITerator it=al.iterator();
 while(it.hasNext())
 {};

------1405
list集合特有的迭代器，ListIterator是Iterator的子接口
在迭代过程中，不可以通过集合对象的方法操作集合中的元素，但ITerator方法有限，只能判断，取出，删除三个操作。为了实现添加和修改等操作，可使用其子接口:ListIterator
该接口只能通过List集合的listIterator方法获取。
例：
ArrayList al=new ArrayList();
ListIterator li=al.listIterator();

------1406
collection
    |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
         |--ArrayList:底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢。
         |--LinkedList:底层使用的链表数据结构，特点：增删速度很快，查询稍慢。
         |--Vector:底层是数组数据结构, 线程同步，被ArrayList替代了。
    |--Set元素是无序的，元素不可以重复
List：
    物有方法,凡是可以操作方法都是该体系特有的方法。
增
 add(index,element);
 addAll(index,Collection);
删
 remove(index);
改
 set(index,element);
查
 get(index);
 subList(from,to);
 listIterator();
 int indexOf(obj);获取指定元素的位置。
 ListIterator listIterator();

------1407
vector枚举，功能与迭代器一样，已被迭代器取代。

ms----1408
LinkedList：特有方法：
addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，且删除元素，如果集合中没有元素，会出现NoSuchElementException

  JDK1.6出现在替代方法：
offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素，如果集合中没有元素，返回null
pollFirst();
pollLast();
获取元素，且删除元素，如果集合中没有元素，返回null

*-----1409
实例：堆栈与队列
import java.util.*;
class DuiLie
{
 private LinkedList link;
 DuiLie()
 {
  link=new LinkedList();
 }
 public void myAdd(Object obj)
 {
  link.addFirst(obj);
 }
 public Object myGet()
 {
  return link.removeFirst();
 }
 public boolean isNull()
 {
  return link.isEmpty();
 }
}
class demo
{
 public static void main(String[] args)
 {
  DuiLie dl=new DuiLie();
  dl.myAdd("a1");
  dl.myAdd("a2");
  dl.myAdd("a3");
  dl.myAdd("a4");
  while(!dl.isNull())
  {
   System.out.println(dl.myGet());
  }
 }
}

------1410
函数返回值可以是ArrayList
例：
public static ArrayList singleElement(ArrayList al)  //传入一个集合，返回一个新的集合
本课讲解示例：给定一个集合，要求去除集合内的重复元素。
想法：
1，给定一个集合(里面有重复元素)
2，利用ArrayList集合中的contains方法，建立新集合
 1)实例化ArrayList
 2)定义迭代器
 3)while(迭代器.hasNext)
 4)利用contains判断，不包含就添加到新集合中
 5)返回新集合

------1411
List集合判断元素是否相同，依据是元素的equals方法。
自定义(person)集合，去除集合内的重复元素：重写object中的equals方法

------1412-15
开发中描素事物存hashset集合中一般都复写hashcode()和equals()
节尾处编程中的小细节
|--Set：元素无序(存入和取出的顺序不一定一致，元素不可以重复。
    |--HashSet: 底层数据结构是哈希表。线程是非同步的。
  HashSet是如何保证元素唯一性的?
  是通过元素的两个方法，hashCode和equals来完成。
  如果元素的HashCode值相同，才会判断equals是否为true。
  如果元素的HashCode值不同，不会调用equals。
  注意：对于判断元素是否存在，以主删除等操作，依赖的方法是元素的HashCode和equals方法。
    |--TreeSet:可以对集合中的对象排序。

Set集合的功能和Collection是一致的。

例：打印HashSet值TreeSet:可以对集合中的对象排序。
import java.util.*;
class Demo
{}
class HashSetDemo
{
 public static void sop(Object.obj)
 {
  System.out.println(obj);
 }
 public static void main(string[] args)
 {
  Demo d1=new Demo();
  Demo d2=new Demo();
  sop(d1);
  sop(d2);
 }
}
Set集合只有一种取出方式：Iterator

集合关系图
                  Collection  ------------------Map
                 +-----+-----+                   |
                 |           |             +-----+----+
               List         Set         HashMap    TreeMap
                 |           |
     +-----------+           +---------+
ArrayList   LinkedList    HashSet   TreeSet

import java.util.*;

public class collectiondemo {

 /**各种集合建立及取出演示
  * @param args
  */
 public static void sop(Object o){
  System.out.println(o);
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
//ArrayList
  ArrayList a1=new ArrayList();
   a1.add("abc");
   a1.add("bcd");
   a1.add("bcd");
   a1.add("cde");
//ArrayList可以打印
   sop("ArrayList-print::"+a1);
//取出方式Iterator
  sop("ArrayList:iterator:");
  Iterator<String> it=a1.iterator();
  while(it.hasNext())
  {
   sop("iterator-next::"+it.next());
  }
//listIterator操作的必须是list集合
  sop("ArrayList:listiterator:");
  ListIterator<String> lit=a1.listIterator();
  while(lit.hasNext())
  {
   sop("listIterator-next::"+lit.next());
  }
//LinkedList
  LinkedList a2=new LinkedList();
   a2.add("abc");
   a2.add("bcd");
   a2.add("bcd");
   a2.add("cde");
   //LinkedList可以打印
   sop("LinkedList-print::"+a2);
//HashSet   
  HashSet a3=new HashSet();
   a3.add("dd");
   a3.add("cc");
   a3.add("cc");
   a3.add("bb");
   //HashSet可以打印
   sop("HashSet-print::"+a3);
//TreeSet
  TreeSet ts=new TreeSet();
   ts.add("ddfdsfdd");
   ts.add("fsff");
   ts.add("fdsdd");
   sop("TreeSet-print::"+ts);

//Map集合
  Map<String,String> m=new HashMap();
   m.put("02","zhangshan");
   m.put("03","zhangshan");
   m.put("01","zhangshan");
   //Map可以打印
   sop("HashMap-print::"+m);
//取出方式
//获取set集合的所有key
  sop("HashMap:keySet:");
  Set<String> keyset=m.keySet();
//迭代器
  Iterator<String> mapsetit=keyset.iterator();
  while(mapsetit.hasNext())
  {
//获取key
   String key=mapsetit.next();
//获取value
   String value=m.get(key);
   sop("key="+key+"  "+"value="+value);
  }
  
  Map<String,String> tm=new TreeMap();
  tm.put("02","zhangshan");
  tm.put("03","zhangshan");
  tm.put("01","zhangshan");
  sop("TreeMap-print:"+tm);

数组与集合的不同：
数组是固定长度，只能存同一类型
集合是可变长度，可以存不同类型

--------集合种类  变量名称=new 集合种类()

集合取出方式(迭代器)：
Iterator 迭代器子对象=集合对象.Iterator();
while(迭代器子对象.hasNext())
{
 System.out.println(迭代器子对象.next());
}

例：
Iterator ital=al.Iterator();
while(ital.hasNext())
{
 System.out.println(ital.next());
}

------1501

TreeSet:可以对集合中的对象排序。

------1503
    |--TreeSet: 可以对Set集合中的元素进行排序。
  底层数据结构是二叉树。
  保证元素唯一性的依据：compareTo方法return 0
  TreeSet排序的第一种方式:
   让元素自身具备比较性，元素需要实现Comparable接口，覆盖compareTo方法。此方式也称为元素的自然顺序，或者叫做loyw默认顺序。
------1504
  TreeSet排序的第二种方式：
   当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
  当两种排序方式都存在时，以比较器为主。
   定义一个类实现Comparator接口，覆盖compare方法
          (注意：Comparable接口里面是compareto方法)
------1505
练习能自己做出来。
------1506
泛型用<>
泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。
好处：1.将运行时期出现问题ClassCastException,思议移到了编译时期，
 方便于程序员解决问题，让运行时期问题减少，安全。
      2.避免了强制转换麻烦。
------1508
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义object来完成扩展，现在定义泛型来完成扩展。
------1510
特殊之处：静态方法不可以访问类上定义的泛型。
   如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
------1512--------导入util包
泛型限定：
<? extends E>可以接收E类型或E的子类型。上限
<? super E>可以接收E类型或者E的父类型。下限
------1601
Map<K,V>   K=key   V=value
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
方法：
    1.添加
 put(K key,V value)
 putAll(Map<? extends K,? extends V> m)
    2.删除
 clear()
 remove(Object key)
    3.判断
 containsValue(Object value)
 containsKey(Object key)
 isEmpty()
    4.获取
 get(Object key)
 size()
 values()

 entrySet()
 keySet()

------1602
Map
 |--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的，jdk1.0 效率低。
 |--HashMap:底层是哈希表数据结构，允许使用null键null值，该集合是线程不同步的。将hashtable替代，jdk1.2 效率高。
 |--TreeMap:底层是二叉树数据结构，线程不同步。可以用于给Map集合中的键进行排序。
和Set很像
其实Set底层就是使用了Map集合。

------1603
hashmap集合null是可以做为键存在的。
可以通过get方法的返回值来判断一个键存在。通过返回null做判断。
注：添加元素，如果出现添加相同的键，那么后添加的值会覆盖原有键对应值。put方法会返回被覆盖的值。

------1604
KeySet<K>取值方式：在通过Set集合的keySet方法取出Set集合的键值，然后迭代器取出Set集合中键通过map的get(key)方法获取键对应的值。

------1605
Map.Entry
泛型嵌套<Map.Entry<String,String>>

------1606
需求：自定义一个学生类存入hashmap中
方法：
1.class.Student
2.set和get方法
3.复写toString方法
4.复写hashCode方法
5.复写equals方法
6.实现comparable<Student>
7.复写compareTo方法
代码：
class Student implements Comparable<Student>
{
 private String name;
 private int age;
 Student(String name,int age)
 { this.name=name;
  this.age=age;}
 public String getName()
 { return name;}
 public int getage()
 { return age;}
 public String toString()
 { return name+":"+age;}
 public int compareTo(Student s)
 { int num=new Integer(this.age).compareTo(new Interger(s.age));
  if(num==0)
   return this.name.compareTo(s.name);
  return num;}
 public int hashCode()
 { return name.hashCode()+age*34;}
 public boolean equals(Object obj)
 { if(!obj instanceof Student))
   throw new ClassCastException("类型不对");
  Student s=(Student)obj;
  return this.name.equals(s.name)&&this.age==s.age;}

 
}

------1710
collections与collection区别：
collection：
collections：静态操作，集合操作，可对list集合进行排序。

------1713
fill方法可以将list集合中所有元素替换成指定元素。
练习：替换集合中的部分
.reverse()反转集合

------1718
增强for循环
格式：for(数据类型 变量名：被遍历的集合(Collection)或着数组)

------1801
没有构造方法的一般都是静态方法。

------1802
Runtime对象，一个单例的应用。
例：
Runtime rt=Runtime.getRuntime();

------1803
有构造方法的，直接new对象就可以了
构造方法就是new对象
Date对象导入的是import java.text.*;

------1805
Math.ceil()
Math.floor()
Math.round()

 

---------------------- android培训、java培训、期待与您交流！ ----------------------