集合框架

集合框架
1：String类：字符串(重点)
(1)多个字符组成的一个序列，叫字符串。
  生活中非常多数据的描写叙述都採用的是字符串的。并且我们还会对其进行操作。
  所以，java就提供了这种一个类供我们使用。

(2)创建字符串对象
A:String():无參构造
**举例：
 String s = new String();
 s = "hello";
 sop(s);
B:String(byte[] bys):传一个字节数组作为參数 *****
**举例
 byte[] bys = {97,98,99,100,101};
 String s = new String(bys);
 sop(s);
C:String(byte[] bys,int index,int length):把字节数组的一部分转换成一个字符串 *****
**举例
 byte[] bys = {97,98,99,100,101};
 String s = new String(bys,1,2);
 sop(s);
D:String(char[] chs):传一个字符数组作为參数 *****
**举例
 char[] chs = {'a','b','c','d','e'};
 String s = new String(chs);
 sop(s);
E:String(char[] chs,int index,int length):把字符数组的一部分转换成一个字符串 *****
**举例
 char[] chs = {'a','b','c','d','e'};
 String s = new String(chs,1,2);
 sop(s);
F:String(String str):把一个字符串传递过来作为參数
 char[] chs = {'a','b','c','d','e'};
 String ss = new String(s);
 sop(ss);
G:直接把字符串常量赋值给字符串引用对象(最经常使用) *****
**举例
 String s = "hello";
 sop(s);
(3)面试题
A:请问String s = new String("hello");创建了几个对象。
 两个。

一个"hello"字符串对象，在方法区的常量池；一个s对象，在栈内存。


B:请写出以下的结果
String s1 = new String("abc");
Strign s2 = new String("abc");
String s3 = "abc";
String s4 = "abc";


sop(s1==s2);  //false
sop(s1==s3);  //false
sop(s3==s4);  //true
C:字符串对象一旦被创建就不能被改变。
指的是字符串常量值不改变。
(4)字符串中各种功能的方法
A:推断
**** boolean equals(Object anObject):推断两个字符串的内容是否同样，复写了Object的方法
**** boolean equalsIgnoreCase(String anotherString):推断两个字符串的内容是否同样。
不区分大写和小写
**** boolean contains(String s):推断一个字符串中是否包括另一个字符串
注意：推断字符串是否包括特殊字符.直接表示为str.contains(".")
boolean endsWith(String suffix):測试此字符串是否以指定的后缀结束
boolean startsWith(String suffix):測试此字符串是否以指定的前缀開始
boolean isEmpty():測试字符串是否为空
B:获取
***** int length():返回此字符串的长度
***** char charAt(int index):返回指定索引处的 char值
***** int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。 
int indexOf(int ch, int fromIndex):返回在此字符串中第一次出现指定字符处的索引，
  从指定的索引開始搜索。 
int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引。 
int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次
出现处的索引，从指定的索引開始。 
*** int lastIndexOf(int ch)：返回指定字符在此字符串中最后一次出现处的索引。 
int lastIndexOf(int ch, int fromIndex) 
返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处開始进行反向搜索。

 
int lastIndexOf(String str) 
返回指定子字符串在此字符串中最右边出现处的索引。 
int lastIndexOf(String str, int fromIndex) 
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引開始反向搜索。 
***** String substring(int beginIndex) (注意：该方法substring的String是小写！

！！

)
返回一个新的字符串。它是此字符串的一个子字符串。 
String substring(int beginIndex, int endIndex) (注意该方法的String是小写！！！)
返回一个新字符串，它是此字符串的一个子字符串,包括头不包括尾。 
C:转换
***** byte[] getBytes()：(非经常常使用。)从字符串到字节数组的方法
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
将字符从此字符串拷贝到目标字符数组。 
***** char[] toCharArray()：(非经常常使用！)从字符串到字符数组的方法
**** static String copyValueOf(char[] data) 
返回指定数组中表示该字符序列的 String。

 
static String copyValueOf(char[] data, int offset, int count) 
返回指定数组中表示该字符序列的 String。 
***** static String valueOf(数据类型):把该数据类型的数据转换成字符串。

*** String toLowerCase()：把字符串转换成小写
String toUpperCase()：把字符串转换成大写
*** 字符串的连接
String concat(String str):将指定字符串连接到此字符串的结尾。
D:替换
String replace(char oldChar, char newChar):用新字符替换旧字符(替换全部)
String replace(String target, String replacement):用新的子串换旧串
E:切割
String[] split(String regex)：依据指定的字符串把一个字符串切割成一个字符串数组
F:
String trim():去除字符串的前后空格
G:
int compareTo(String anotherString) 
按字典顺序比較两个字符串。 
int compareToIgnoreCase(String str) 
按字典顺序比較两个字符串，不考虑大写和小写。 
(5)练习
1:模拟登录,给三次机会,并提示还有几次.
默认的username和password为admin。 区分大写和小写。

自己从键盘输入username和password。

2:给定一个字符串统计,统计大写字母,小写字母,数字出现的个数.
***注意:不包括特殊字符
从键盘输入一个不包括特殊字符的字符串(仅仅有26个字母和0-9组成)。


3:给定一个字符串,把它变成首字母大写,其它字母小写的字符串.
从键盘输入一个字符串。全部26个字母组成的。


4:子串在整串中出现的次数。
也就是说:获取一个字符串中,指定的字串在该字符串中出现的次数.
比如:
"nbasdnbafllgnbahjnbakqqqqlnba"  在这个字符串中，多有个nba.


5:对字符串中字符进行自然顺序排序。
"basckd"-->"abcdks"


先留做思考内容：
6:两个字符串的最大同样子串。
两个字符串的最大同样子串。
比方:
"sadabcdfghjkl"
werabcdtyu"


2：StringBuffer
(1)字符串的缓冲区，是一个容器。

(2)它和String的差别
它是缓冲区可变长度的。
(3)构造方法
StringBuffer() 构造一个当中不带字符的字符串缓冲区，初始容量为 16 个字符。
StringBuffer(int num) 构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer(String str) 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
(4)经常用法
A:添加数据
**append ：加入各种类型的数据
**insert : 在容器指定位置插入各种类型的数据。

B:删除数据
**deleteCharAt : 删除指定位置的字符
**delete 还能够用于清空StringBuffer的缓冲区
C:替换
**replace
D:获取 
**charAt 
E:长度和容量
**length() 元素的个数
**capacity 元素的理论值
F:获取元素的位置
**indexOf
**lastIndexOf
G:截取
**substring(int start)
**substring(int start,int end)
H:反转
**reverse
(5)字符串和StringBuffer的转换
String-->StringBuffer通过构造:
如:StringBuffer sb = new StringBuffer(String str)
StringBuffer--String通过toString方法 
如:StringBuffer sb = new StringBuffer();
  sb.toString();


3：StringBuilder
和StringBuffer的功能是一样的，可是有差别：
StringBuffer(JDK1.0)是线程安全的。
StringBuilder(JDK1.5)不保证线程安全。


一般来说，我们写的程序都是单线程的，所以，用StringBuilder，效率高。


JDK版本号的升级原则：
A:提高效率
B:提高安全性
C:简化书写


4：基本数据类型的对象包装类
(1)为了更方便的操作每一个基本数据类型，java对其提供了非常多的属性和方法供我们使用。
(2)用途：
**将基本数据类型封装成对象的优点在于能够在对象中定义很多其它的功能操作该数据。
**经常使用的操作之中的一个：用于基本数据类型与字符串之间的转换。
A:方便操作
B:用于和字符串进行相互转换
(3)基本数据类型和对象类型的相应
byte Byte
short Short 
int Integer
long Long
float Float
double Double
boolean Boolean
char Character
(4)构造方法


字段摘要：
static int MAX_VALUE 值为 2^31-1 的常量。它表示 int 类型能够表示的最大值         
static int MIN_VALUE  值为 -2^31 的常量，它表示 int 类型能够表示的最小值
static Class<Integer> TYPE 表示基本类型int的Class 实例
          
Integer(int value) 构造一个新分配的Integer对象，它表示指定的int值。
Inreger(String s) 注意：s必须是纯数字的字符串。

否则会有异常NumberFormatException
                       
(5)几个经常使用的方法
Integer.toBinaryString();
以二进制（基数 2）无符号整数形式返回一个整数參数的字符串表示形式。
Integer.toOctalString();
以八进制（基数 8）无符号整数形式返回一个整数參数的字符串表示形式。
Integer.toHexString();
以十六进制（基数 16）无符号整数形式返回一个整数參数的字符串表示形式。
static int Integer.parseInt(String s) 将字符串參数作为有符号的十进制整数进行解析,
字符串必须是int型范围内的数字字符串
static int Integer.parseInt(String s,int basic) 
使用第二个參数指定的基数,将字符串參数解析为有符号的整数.
字符串必须是int型范围内的数字字符串
short shortValue() 以short类型返回该Integer的值。

         
int intValue() 以int类型返回该Integer的值。  
static Integer valueOf(int num) 返回一个表示指定的 int 值的 Integer 实例。
static Integer valueOf(String s) 返回保存指定的String的值的Integer对象。

          
                static Integer valueOf(String s, int radix) 
返回一个Integer对象，该对象中保存了用第二个參数提供的基数进行
解析时从指定的String中提取的值。 


(6)类型转换
int -- Integer
int num = 20;
A:Integer i = new Integer(num);
B:Integer i = Integer.valueOf(num);
Integer -- int
Integer i = new Integer(20);
A:int num = i.intValue();

int -- String
int num = 20;
A:String s = String.valueOf(num);
B:String s = ""+num;
C:String s = Integer.toString(num);
String -- int
String s = "20";
A:int num = Integer.parseInt(s);
B:Integer i = new Integer(s);或者Integer i = Integer.valueOf(s);
 int num = i.intValue();
6、集合框架：
(1)为什么出现集合类？
面向对象对事物的体现都是以对象的形式，为了方便对多个对象的操作，就对对象进行存储。

集合就是存储对象最经常使用的一种方式.
(2)数组和集合都是容器。两者有何不同？
**数组长度固定，而集合长度是可变的
**数组值能够存储对象。还能够存储基本数据类型;而集合仅仅能存储对象
**数组存储数据类型是固定的。而集合存储的数据类型不固定
(3)集合类的特点：
集合仅仅能存储对象
集合的长度是可变的
集合能够存储不同类型的对象
(4)集合类框架(重要！！

！

要分清几种容器间的差别)：
**Collection:顶层接口
    |--->List:列表。元素是有序的(元素带角标索引)。能够有反复元素,能够有null元素。
           |--->ArrayList(JDK1.2):底层的数据结构是数组数据结构。特点是查询速度快(由于带角标)。
  可是增删速度稍慢,由于当元素多时，增删一个元素则全部元素的角标都得改变
  线程不同步。

默认长度是10，当超过长度时，按50%延长集合长度。

  
   |--->LinkedList(JDK1.2):底层数据结构式链表数据结构(即后面一个元素记录前一个)，
   特点：查询速度慢，由于每一个元素仅仅知道前面一个元素，但增删速度快
   由于元素再多。增删一个。仅仅要让其前后的元素又一次相连即可
   线程是不同步的。

   |--->Vector(JDK1.0):底层数据结构是数组数据结构.特点是查询和增删速度都非常慢。

默认长度是10。当超过长度时,按100%延长集合长度。
线程同步。
(Vector功能跟ArrayList功能一模一样。已被ArrayList替代)




  **List使用注意！

|--->ArrayList:
(1)当往ArrayList里面存入元素没什么要求时。即仅仅要求有序即可时。
  
(2)当往ArrayList里面存入元素要求不反复时，比方存入学生对象，当同名同姓时
  视为同一个人，则不往里面存储。则定义学生对象时。需复写equals方法
  public boolean equals(Object obj)
  {
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
  }
  则往ArrayList集合通过add存入学生对象时，集合底层自己会调用学生类的equals方法。
  推断反复学生则不存入。
注：对于List集合。不管是add、contains、还是remove方法。推断元素是否同样，
    都是通过复写equals方法来推断！


|--->LinkedList
(1)LinkLedist的特有方法：
boolean offerFirst(E e)  在此列表的开头插入指定的元素。
boolean offerLast(E e) 在此列表末尾插入指定的元素。
E peekFirst() 获取但不移除此列表的第一个元素；假设此列表为空，则返回 null。

E peekLast() 获取但不移除此列表的最后一个元素。假设此列表为空，则返回 null。
E pollFirst() 获取并移除此列表的第一个元素。假设此列表为空，则返回 null。
E pollLast() 获取并移除此列表的最后一个元素；假设此列表为空，则返回 null。
(2)通过LinkLedist的特有方法。能够实现某些数据特殊方式的存取。比方堆栈和队列。


普通情况下，使用哪种List接口下的实现类呢？
假设要求增删快。考虑使用LinkedList
假设要求查询快，考虑使用ArrayList
假设要求线程安全。考虑使用Vector。






    |--->Set:集合，元素是无序的(由于没有索引)，元素不能够反复。能够有null元素。
   |--->HashSet(JDK1.2):底层数据结构是哈希表、存取速度快、元素唯一、线程不同步。
保证性元素唯一的原理:
先推断元素的hashCode值是否同样。再推断两元素的equals方法是否为true
(往HashSet里面存的自己定义元素要复写hashCode和equals方法，
以保证元素的唯一性！

)
   |--->TreeSet:底层数据结构式二叉树。能够对Set集合中的元素进行排序。

元素有序、线程不同步。
保证元素唯一性的依据：compareTo方法return 0
TreeSet排序的第一种方式:让元素自身具备比較性。比方八种基本数据类型或则字符串，
实现Compareble接口,覆盖compareTo方法，
此方式是元素的自然顺序  
TreeSet排序的第一种方式:当元素自身不具备比較性(比方存储学生对象时)或者具备的
比較性不是我们所须要的比較性时(比方想字符串的长度排序),
此时就须要让集合自身具备自己定义的比較性。

 
那怎样让集合自身具备比較性呢？可在集合初始化时，
就让集合具备比較方式。即定义一个类。
实现Comparator接口。覆盖compare方法。


**Set集合使用注意事项：
(1)HashSet:
     通过new的方式往HashSet里面存的元素的hashCode都不同。但通常我们定义对象，
     比方学生对象时。尽管是new的两个学生对象。可是当他们name和age一样时，我们觉得是
     同一个对象，所以为了保证元素的唯一性。我们通常在往HashSet集合里面存储元素时，
     在定义对象的类中通常复写hashCode和equals方法。
    

 public int hashCode()
     {
return name.hashCode()+age*39;
     }
     public boolean equals(Object obj)
     {
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
     }

    HashSet是怎样保证元素唯一性的呢？
     **假设两元素的hashCode值不同。则不会调用equals方法
     **假设两元素的hashCode值同样。则继续推断equals是否返回true。
     **hashCode和equals方法尽管定义在自己定义对象类里面，但不是我们手动调用
       而是往HashSet集合里面存储元素的时候。集合底层自己调用hashCode和equals
它自己拿对象去推断，自己推断两元素是否是同一个元素。


(2)TreeSet:
    TreeSet要求往里面存的元素具备比較性。否则会报错。

    TreeSet排序的第一种方式:让元素自身具备比較性
 定义对象类，实现Compareble接口,复写compareTo方法，此方式是元素的自然顺序
 

class Student implements Comparable
 {
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象。");
Student stu = (Student)obj;
int num = this.age-stu.age;
if(num==0)
return this.name.compareTo(stu.name);
return num;
}
 }
   TreeSet排序的第一种方式:让集合具备比較性
当元素自身不具备比較性(比方存储学生对象时)或者具备的
比較性不是我们所须要的比較性时(比方想字符串的长度排序),
此时就须要让集合自身具备自己定义的比較性。 
那怎样让集合自身具备比較性呢？可在集合初始化时。
就让集合具备比較方式。即定义一个类。
实现Comparator接口，覆盖compare方法。
class StringLengthComparator implements Comparator
{
public int compare(Object obj1,Object obj2)
{
String s1 = (String)obj1;
String s2 = (String)obj2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StringLengthComparator());
ts.add("addfg");
ts.add("dfg");
ts.add("agtuug");
ts.add("vgjkg");
sop(ts);
}
}

 

    基本数据类型或字符串对象均实现了Comparable接口。故同种类型基本数据间具备比較性，即自然顺序。

     
**Map:顶层接口,该集合存储的是键值对,并且键是唯一的,Map和Set非常像,Set集合底层就是使用了Map集合。
Map集合没有迭代器，要取出元素必须先将Map集合转换成Set集合才干遍历元素
  |--->HashTable(JDK1.0): 
底层是哈希表数据结构；
不能够使用null键和null值。
用作键的对象必须实现hashCode和equals方法来保证键的唯一性
线程同步，效率低
  |--->HashMap(JDK1.2):
底层是哈希表数据结构；
同意使用null键和null值。
线程不同步，效率高；
保证元素唯一性的:
原理：先推断元素的hashCode值是否同样，再推断两元素的equals方法是否为true
(往HashSet里面存的自己定义元素要复写hashCode和equals方法，
以保证元素的唯一性！

)

class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

@Override
public int hashCode(){
return name.hashCode()+age*34;
}
@Override
public boolean equals(Object obj){

if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}
public class HashMapDemo1 {
public static void main(String[] args) {
Map<Student , String> hmap = new HashMap<Student , String>();
hmap.put(new Student("001",20), "beijing");
hmap.put(new Student("002",25), "hebei");
hmap.put(new Student("003",50), "hainan");
hmap.put(new Student("001",20), "beijing");

System.out.println(hmap.size());
Set<Student> keySet = hmap.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext()){
Student stu = it.next();
String addr = hmap.get(stu);
System.out.println(stu.getName()+".."+stu.getAge()+"::"+addr);
} 
} 
} 

  |--->TreeMap(JDK1.0):
底层是二叉树结构；
同意使用null键和null值；
线程不同步。
能够给Map集合中的键进行排序.
TreeMap排序的第一种方式:让元素自身具备比較性，比方八种基本数据类型或则字符串，
实现Compareble接口,覆盖compareTo方法，
此方式是元素的自然顺序  
TreeMap排序的第一种方式:当元素自身不具备比較性(比方存储学生对象时)或者具备的
比較性不是我们所须要的比較性时(比方想字符串的长度排序),
此时就须要让集合自身具备自己定义的比較性。 
那怎样让集合自身具备比較性呢？可在集合初始化时，
就让集合具备比較方式。即定义一个类，
实现Comparator接口，覆盖compare方法。

class Student implements Comparable<Student>{
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Student stu) {
int num = new Integer(this.age).compareTo(new Integer(stu.age));
if(num==0)
return this.name.compareTo(stu.name);
return num;
} 
}


public class HashMapDemo1 {
public static void main(String[] args) {

Map<Student , String> tmap = new TreeMap<Student , String>();
tmap.put(new Student("001",20), "beijing");
tmap.put(new Student("002",25), "hebei");
tmap.put(new Student("003",50), "hainan");
tmap.put(new Student("001",20), "beijing");

System.out.println(tmap.size());
Set<Student> keySet1 = tmap.keySet();
Iterator<Student> it1 = keySet1.iterator();
while(it1.hasNext()){
Student stu = it1.next();
String addr = tmap.get(stu);
System.out.println(stu.getName()+".."+stu.getAge()+"::"+addr);
}
}
}

**Iterator：对collection进行迭代的迭代器.迭代器代替了Enumeration。
迭代器和枚举的差别：
迭代器同意调用者利用定义良好的语义在迭代期间从迭代器所指向的collection移除元素
方法名称得到了改进，简化书写 
**LisIterator：系列表迭代器。同意程序猿按任一方向遍历列表、迭代期间改动列表
**Comparable：此接口强行对实现它的每一个类的对象进行总体自然排序。使元素具备比較性
**Comparator：强行对某个对象collection进行总体排序的比較函数，使集合具备比較性
**Collections：此类全然由在 collection 上进行操作或返回 collection 的静态方法组成。

**Arrays：此类包括用来操作数组(比方排序和搜索)的各种静态方法


7、集合类各容器方法：
**接口Collection方法摘要(没有构造方法)
a)加入：
i.  boolean add(E e)
j.  boolean addAll(Collection c)
b)删除：
i.  void clear():清空容器
j.  boolean remove(Objec object):
k.  boolean removeAll(Collection c):
c)推断：
i.  boolean contains(Object object):推断是否包括此元素
j.  boolean containsAll(Collection c):推断是否包括一堆元素
k.  boolean equals(Object object):比較此collection与指定对象是否相等
m.  boolean isEmpty():推断是否集合为空
d)获取：
h.  Iterator iterator():取出
i.  int hashCode():返回此collection的哈希值
j.  int size():返回此collection中元素的个数
k.  boolean retainAll(Collection c):取交集
m.  Object toArray():返回此collection中全部元素的数组
n.  T[] toArray(T[] a):返回包括此collection中全部元素的数值。
*****List集合子类及其方法
(1)List接口是Collection接口的一个子接口。
(2)List接口中的元素有例如以下特点(对角标的操作都是特有方法，由于有序)：
A:元素有序(存储顺序和取出顺序一致)
B:元素能够反复
(3)List接口中的特有方法
A:add(int index,Object obj):在指定位置加入元素
B:remove(int index):移除指定位置的元素
C:set(int index,Object obj):改动指定位置的元素
D:get(int index):获取指定位置的元素
E:indexOf(Object obj):获取指定元素的位置
F:subList(int start,int end):从一个大的List中截取一个小的List
G:listIterator():返回一个List接口特有的迭代器
(1)、ArrayList：
    |--->构造方法摘要：(少用。不是重点)
ArrayList()：构造一个初始容量为 10 的空列表。
ArrayList(Collection<? extends E> c)： 构造一个包括指定 collection 的元素的列表，  
ArrayList(int initialCapacity)： 构造一个具有指定初始容量的空列表。

    |--->方法摘要：
|--->加入：
boolean add(E e)： 将指定的元素加入到此列表的尾部。
void add(int index, E element)： 将指定的元素插入此列表中的指定位置。
boolean addAll(Collection<? extends E> c):依照指定 collection 的迭代器所返回的元素顺序，
将该 collection 中的全部元素加入到此列表的尾部 
boolean addAll(int index, Collection<? extends E> c)： 从指定的位置開始。将指定 collection
      中的全部元素插入到此列表中。 
|--->删除：
void clear(): 移除此列表中的全部元素。
E remove(int index): 移除此列表中指定位置上的元素。 
boolean remove(Object o): 移除此列表中首次出现的指定元素（假设存在）。
protected  void removeRange(int fromIndex, int toIndex): 
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的全部元素。
boolean removeAll(Collection<?> c): 从列表中移除指定 collection 中包括的其全部元素 
|--->获取：
E get(int index): 返回此列表中指定位置上的元素。

int indexOf(Object o): 返回此列表中首次出现的指定元素的索引。或假设此列表不包括元素。则返回 -1。
int lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引，或假设此列表不包括索引，则返回 -1。

  
public List<E> subList(int fromIndex,int toIndex): 返回列表中指定的 fromIndex（包括 ）  和 toIndex（不包括）之间的部分视图。

Iterator<E> iterator(): 返回按适当顺序在列表的元素上进行迭代的迭代器。
ListIterator<E> listIterator(int index):返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置開始。
|--->改动：(特有方法！

！)
E set(int index, E element): 用指定的元素替代此列表中指定位置上的元素。 
(2)LinkedList:
|--->构造方法摘要：
LinkedList(): 构造一个空列表。

 
LinkedList(Collection<? extends E> c): 构造一个包括指定 collection 中的元素的列表。
      这些元素按其 collection 的迭代器返回的顺序排列。
|--->方法摘要:(特有的)
|--->加入
void addFirst(E e): 将指定元素插入此列表的开头。

 
void addLast(E e): 将指定元素加入到此列表的结尾。 
|--->获取元素，但不删除元素
E get(int index): 返回此列表中指定位置处的元素。

          
E getFirst(): 返回此列表的第一个元素。          
E getLast(): 返回此列表的最后一个元素。

|--->获取元素且删除元素
E remove()： 获取并移除此列表的头（第一个元素）。          
E remove(int index)： 移除此列表中指定位置处的元素。         
boolean remove(Object o)： 从此列表中移除首次出现的指定元素（假设存在）。         
E removeFirst()： 移除并返回此列表的第一个元素。 
E removeLast(): 移除并返回此列表的最后一个元素。
|--->改动
E set(int index, E element) 将此列表中指定位置的元素替换为指定的元素。 
(3)Vector
|--->构造方法摘要：
Vector(): 构造一个空向量。使其内部数据数组的大小为 10，其标准容量增量为零。          
Vector(Collection<?

extends E> c):  构造一个包括指定 collection 中的元素的向量，
   这些元素按其 collection 的迭代器返回元素的顺序排列。

|--->方法摘要：
|--->加入：
boolean add(E e): 将指定元素加入到此向量的末尾。

void add(int index, E element): 在此向量的指定位置插入指定的元素。         
boolean addAll(Collection<? extends E> c):
将指定 Collection 中的全部元素加入到此向量的末尾， 
依照指定 collection 的迭代器所返回的顺序加入这些元素。 
boolean addAll(int index, Collection<? extends E> c): 在指定位置将指定 Collection 中的全部元素插入到此向量中。
|--->获取:
Enumeration<E> elements(): 返回此向量的组件的枚举。
  Vector特有的取出方式:
  枚举和迭代器非常像，事实上枚举和迭代器是一样的，仅仅是由于枚举的名称和方法的名称
  名字都过长，所以枚举被迭代器代替了。
|--->枚举Enumeration的方法摘要：
boolean hasMoreElements(): 測试此枚举是否包括很多其它的元素。

 
E nextElement(): 假设此枚举对象至少另一个可提供的元素，
 则返回此枚举的下一个元素。

 
*****Set集合子类及其方法
(1)HashSet:它不保证set的迭代顺序;特别是它不保证该顺序恒久不变.此类同意使用null元素。 
|--->构造方法：
HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，载入因子是 0.75。
HashSet(Collection<? extends E> c) 构造一个包括指定 collection 中的元素的新 set。
|--->方法摘要：
boolean add(E e) 假设此 set 中尚未包括指定元素。则加入指定元素。

  
void clear() 从此 set 中移除全部元素。 
Object clone() 返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。

 
boolean contains(Object o) 假设此 set 包括指定元素。则返回 true。 
boolean isEmpty() 假设此 set 不包括不论什么元素，则返回 true。  
Iterator<E> iterator() 返回对此 set 中元素进行迭代的迭代器。 
boolean remove(Object o) 假设指定元素存在于此 set 中，则将其移除。

  
int size() 返回此 set 中的元素的数量（set 的容量）。

 
(2)TreeSet:使用元素的自然顺序对元素进行排序，或者依据创建 set 时提供的 Comparator 进行排序.
|--->构造方法：
TreeSet() 构造一个新的空 set，该set依据其元素的自然顺序进行排序。

         
TreeSet(Collection<? extends E> c) 
构造一个包括指定 collection 元素的新 TreeSet，它依照其元素的自然顺序进行排序。

 
TreeSet(Comparator<?

super E> comparator)  构造一个新的空 TreeSet，它依据指定比較器进行排序。
|--->方法摘要：
加入：
boolean add(E e)  将指定的元素加入到此 set（假设该元素尚未存在于 set 中）。
boolean addAll(Collection<? extends E> c) 将指定 collection 中的全部元素加入到此 set 中。
删除：
 void clear() 移除此 set 中的全部元素。

 
 boolean remove(Object o)  将指定的元素从 set 中移除（假设该元素存在于此 set 中）。 
 E pollFirst() 获取并移除第一个（最低）元素。假设此 set 为空。则返回 null。 
 E pollLast() 获取并移除最后一个（最高）元素。假设此 set 为空。则返回 null。 
获取：
 Iterator<E> iterator()  返回在此 set 中的元素上按升序进行迭代的迭代器。
 E first() 返回此 set 中当前第一个（最低）元素。
 E last() 返回此 set 中当前最后一个（最高）元素。

 int size()  返回 set 中的元素数（set 的容量）。

推断：
boolean isEmpty()  假设此 set 不包括不论什么元素，则返回 true。

 
boolean contains(Object o) 假设此 set 包括指定的元素，则返回 true。

 
**Map:将键映射到值的对象。Map集合没有迭代器。Map集合特点：该集合存储键值对。

并且键是唯一的。

|--->方法摘要：
  |--->加入：
     V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。           
     void putAll(Map<?

extends K,?

extends V> m) 从指定映射中将全部映射关系拷贝到此映射中
  |--->删除：
              void clear()  从此映射中移除全部映射关系（可选操作）。 
     V remove(Object key) 假设存在一个键的映射关系。则将其从此映射中移除（可选操作）。

  |--->推断
     boolean containsKey(Object key) 假设此映射包括指定键的映射关系。则返回 true。 
              boolean containsValue(Object value) 假设此映射将一个或多个键映射到指定值，则返回 true。

              boolean isEmpty() 假设此映射未包括键-值映射关系。则返回 true。 
           |--->获取
     int size() 返回此映射中的键-值映射关系数。 
              Collection<V> values()  返回此映射中包括的值的 Collection 视图。

      重点：Map集合没有迭代器。以下是Map的两种取出方式：
      第一种：Set<K> keySet()
返回此映射中包括的键的Set视图。将Map集合中全部的键存入Set集合，然后再通过Set集合的
迭代器取出全部的键。再依据get方法获取每一个键的值；
      另外一种：Set<Map.Entry<K,V>> entrySet() 
返回此映射中包括的映射关系的Set视图，将Map集合中的映射关系存入到Set集合中，
这个映射关系的数据类型是Map.entry,再通过Map.Entry类的方法再要取出关系里面的键和值
Map.Entry的方法摘要：
boolean equals(Object o)  比較指定对象与此项的相等性。 
K getKey()  返回与此项相应的键。

 
V getValue() 返回与此项相应的值。

  
int hashCode() 返回此映射项的哈希码值。

V setValue(V value) 用指定的值替换与此项相应的值(特有！

！！

)。
8、Map集合和Collection集合的差别？
1。
Map中一次存储是键值对。
Collection中一次存储是单个元素。
2，
Map的存储使用的put方法。
Collection存储使用的是add方法。

 
3，
Map集合没有迭代器，Map的取出，是将Map转成Set，在使用迭代器取出。

Collection取出，使用就是迭代器。
4，
假设对象非常多，必须使用集合存储。

假设元素存在着映射关系，能够优先考虑使用Map存储或者用数组，
假设没有映射关系，能够使用Collection存储。

8、迭代器：Iterator(Map集合没有迭代器)
(1)迭代器就是取出集合元素的方式
(2)迭代器的作用
由于每一个集合中元素的取出方式都不一样，于是就把元素的取出方式进行抽取，并定义在集合内部，
这样取出方式就能够直接訪问集合内部的元素；
而每一个容器的数据结构不同，所以取出动作的细节也不一样，可是有共性内容：推断和取出。

那么就将共性内容进行抽取。从而形成了接口Iterater
(3)获取迭代器的方法：
Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。

 
Iterator<E> iterator() 返回在此 set 中的元素上进行迭代的迭代器。      
(3)迭代器方法：
boolean hasNext() 假设仍有元素能够迭代,则返回 true。
E next() 返回迭代的下一个元素。       
void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）。
9、列表迭代器：ListIterator
(1)List集合特有的迭代器ListIterator是Iterator的子接口，在迭代时，不能够通过集合对象的
  方法操作集合中的元素。由于会发生ConcurrentModificationException(当方法检測到对象的并发改动，
  但不同意这种改动时，抛出此异常)
(2)Iterator方法有限。仅仅能对元素进行推断、取出和删除的操作
  ListIterator能够对元素进行加入和改动动作等。

(3)获取列表迭代器方法：
ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。 
ListIterator<E> listIterator(int index) 
返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置開始。

 
(4)列表迭代器方法：
void add(E e) 将指定的元素插入列表（可选操作）。

boolean hasPrevious()  假设以逆向遍历列表，列表迭代器有多个元素，则返回 true。

 
int nextIndex() 返回对 next 的兴许调用所返回元素的索引。         
E previous() 返回列表中的前一个元素。

 
int previousIndex() 返回对 previous 的兴许调用所返回元素的索引。 
void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。 
10、堆栈和队列
堆栈：先进后出，比方杯子里的水
队列：先进先出，比方水管的水
11、集合类各种容器的使用注意细节：
(1)迭代器：
**迭代器的next方法是自己主动向下取元素。要避免出现NoSuchElementException。
 也就是在迭代循环中调用一次next方法一次就要hasNext推断一次。比方语句
 sop(it.next()+"..."+it.next())会发生上述异常。

**迭代器的next方法返回值类型是Object。所以要记得类型转换,应用泛型后就不用强转
(2)List集合：
**List集合里面的元素由于是带角标。所以List集合里面的元素都是有序的，
 另外List集合能够包括反复元素。也能够包括null。

 
**List集合有迭代器Iterator，另一个特有迭代器列表ListIterator
**List集合中推断元素是否同样都是用equals方法。不管contains、remove都依赖equals方法
 比方往ArrayList集合里面存放学生。同名同年龄视为同一个人，此时就须要在学生类复写Object类
 里面的equals方法(非常重要！！

！

要注意。。)
(3)Set集合：
**Set接口里面存放的是元素是无序的，不能够有反复元素，能够包括null
**Set集合仅仅有一种取出方式，就是迭代器Iterator
**Set集合功能和Collection是一致的，没有特殊方法
   |--->HashSet:
**集合里面存放的元素是无序的。唯一的
**底层数据结构是哈希表，哈希表结构的数据都是无序的，哈希表结构的操作效率都高效
**线程不同步
**保证元素唯一性的原理是：通过复写hashCode和equals方法
****假设两元素的hashCode值同样，则继续推断两元素equals是否为真
****假设两元素的hashCode值不同。则不会调用equals方法。

**当我们往HashSet集合存放自己定义的元素时(比方学生对象)。通常都要复写hashCode和equals方法。
 并且hashCode和equals方法不通过我们调用，HashSet集合底层内部自己调用，自己拿元素去比較
   |--->TreeSet
**TreeSet集合能够对存放的元素进行排序，弥补了Set集合元素无序的缺点，且元素是唯一的
**底层数据结构是二叉树，二叉树结构都是有序的
**线程不同步
**TreeSet集合要求往集合里存放的元素自身具备比較性。否则会报错
**TreeSet集合保证元素唯一性的依据是：通过compareTo或者compare方法中的来保证元素的唯一性。
TreeSet排序的第一种方式:让元素自身具备比較性，
定义元素类实现Compareble接口。覆盖compare方法，
此方式是元素的自然顺序。
TreeSet排序的另外一种方式:让集合具备比較性
当元素自身不具备比較性或者具备的比較性不是
我们所须要的比較性时，此时就须要让集合具备自己定义的比較性。
那怎样让集合自身具备比較性呢？
可在集合初始化时。就让集合具备比較方式。
即定义一个类。实现Comparator接口，覆盖compare方法。
注：
**推断元素唯一时，当主要条件一样时。推断次要条件
**两种排序方式都在时，以比較器为主。！！
(4)Map集合：
|--Hashtable
底层是哈希表结构
线程安全的。并且键和值不能为null。

|--HashMap
底层是哈希表结构
线程不安全的，键和值能够为null。
|--LinkedHashMap
底层是链表和哈希表
线程不安全
|--TreeMap
底层是二叉树
线程不安全的
12、假设你想将一组对象按一定顺序存取。在不考虑并发訪问的情况下会使用____C_____ , 
反之则会使用____A_____；假设你想存储一组无序但唯一的对象，你会使用___B______ ; 
假设你想按keyword对对象进行存取，在不考虑并发訪问的情况下会使用___D______ ,反之则会使用_____E____。
A. Vector
B. HashSet
C. ArrayList
D. HashMap
E. Hashtable