List集合
List集合的特点:有顺序可重复
List是继承自Collection，Collection中的方法在List中都是存在。
List集合中的特性方法:
因为List集合是有顺序的，我们可以对其元素进行精确控制，通过索引.
1.add方法
声明:public void add(int index,Object obj);
作用:在指定index索引位置添加元素
//add(int index,Object obj)
public static void method1(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add(1,"ok"); //这个方法的作用是将ok添加到1这个索引的位置
System.out.println(list);
}
2.get方法(***)
声明:public Object get(int index);
作用:根据索引index得到对应位置上的元素
//Object get(int index)
public static void method2(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add("ok");
//String obj=(String)list.get(1);
//System.out.println(obj);
for(int i=0;i<list.size();i++){
String s=(String)list.get(i);
System.out.println(s);
}
}
3.remove方法
声明:public Object remove(int index);
作用:将指定index索引位置上的元素删除，返回值就是删除的元素.
//remove
public static void method3(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add("ok");
Object obj=list.remove(0);
System.out.println(list);
System.out.println("obj="+obj);
}
4.set方法
声明:public Object set(int index,Object obj)
作用:使用obj将index位置上的元素替换，返回值是被替换的元素.
//set
public static void method4(){
List list=new ArrayList();
list.add("hello");
list.add("world");
list.add("ok");
Object obj=list.set(1,"小张");
System.out.println(list);
System.out.println("obj="+obj);
}
List集合的遍历方式
1.通用方式 Iterator（适用于所有的Collection集合）
通过从Collection继承的iterator方法
//1.使用迭代器
public static void method1(){
List list=new ArrayList();
list.add("张三丰");
list.add("张无忌");
list.add("李莫愁");
list.add("吴莫愁");
for(Iterator it=list.iterator();it.hasNext();){
String s=(String)it.next();
System.out.println(s);
}
}
2.使用get（只适用于List集合）
因为List集合是有顺序的，我们可以通过索引对其位置上进行控制
//2.使用索引进行操作
public static void method2(){
List list=new ArrayList();
list.add("张三丰");
list.add("张无忌");
list.add("李莫愁");
list.add("吴莫愁");
for(int i=0;i<list.size();i++){
String s=(String)list.get(i);
System.out.println(s);
}
}
3.使用List集合的特有的迭代器械 ListIterator(只适用于List集合)
ListIterator是继承自Iterator，也就是在Iterator中声明的hasNext,next,remove方法它也有。
但是它还提供了特有的方法 add set
//3.使用ListIterator
public static void method3(){
List list=new ArrayList();
list.add("张三丰");
list.add("张无忌");
list.add("李莫愁");
list.add("吴莫愁");
//在迭代的过程中对元素进行操作
ListIterator lt=list.listIterator();
while(lt.hasNext()){
String s=(String)lt.next();
if("张三丰".equals(s)){
//lt.add("梅超疯"); //在迭代过程中对元素进行操作
lt.set("梅超疯");
}
//System.out.println(s);
}
System.out.println(list);
/*
while(lt.hasPrevious()){
String s=(String)lt.previous();
System.out.println(s);
}*/
}
ListIterator比Iterator功能增强
1.Iterator只能从上到下遍历，而ListIterator可以双向遍历
2.Iterator在迭代过程中不能修改,而ListIterator可以add ,set
ArrayList
我们主要研究，ArrayList的实现方式
ArrayList它的实现是使用可变数组
ArrayList类的特点:
1.它的底层实现是使用数组实现。
2.每一次数组会扩充50%
（trimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小。）
3.它是线程不安全。在单线程中使用。
class MyList
{
private Object[] obj;
private int size=0;
public MyList(){
this(10);
}
public MyList(int len){
obj=new Object[len];
}
public void add(Object o){
obj[size]=o;
//为了实现可以一直向MyList中不断的添加元素.
change();
size++;
}
private void change(){
Object[] old=obj;
obj=new Object[old.length*3/2]; //在原来数组基础上扩大50%
/*
for(int i=0;i<old.length;i++){
obj[i]=old[i];
}*/
}
public String toString(){
StringBuilder builder=new StringBuilder();
builder.append("[");
for(int i=0;i<size;i++){
builder.append(obj[i]).append(",");
}
builder.deleteCharAt(builder.length()-1);
builder.append("]");
return builder.toString();
}
}
LinkedList
特点：
LinkedList的底层实现:双向链表
LinkedList特殊的方法:它可以很方便的操作集合的头尾元素.
它对外提供了 get/remove/add
关于ArrayList与LinkedList集合区别?
ArrayList底层是使用数组实现，在内存中是连续的空间，那么他在做查找时会方法，
但是在做删除/修改时效率比较低.
LinkedList它的底层实现是链表实现，它在做查找时效率比较低。转为每一个元素
头存储的是上一个元素的地址，尾存储的是下一个元素的地址。
但是，它在做删除与修改时效率高。
LinkedList集合的特性方法
1.addFirst/addLast
声明:public void addFirst(Object obj);
作用:将obj元素添加到集合的首位置
声明:public void addLast(Object obj)
作用:将obj元素添加到集合的尾位置
//在jdk1.6后提供两个替代的方法
offerFirst
offerLast
它与我们addFirst与addLast区别在于它有返回值.
//addFirst addLast
public static void method1(){
LinkedList list=new LinkedList();
list.add("a");
list.add("b");
list.addFirst("abc");
list.addFirst("first");
list.add("c");
list.addLast("d");
list.add("e");
System.out.println(list);
}
2.getFirst/getLast
声明:public Object getFirst();
作用:得到集合中的首元素
声明:public Object getLast();
作用:得到集合的尾元素
在jdk1.6后提供替代方法
peekFirst
peekLast
它们与getFirst/getLast区别,它们在集合为空时，返回的是null,而不会产生异常.
//getFirst getLast
public static void method2(){
LinkedList list=new LinkedList();
//list.add("a");
//list.add("b");
//list.add("c");
//list.add("d");
//list.add("e");
System.out.println(list.getFirst()); //list.get(0);
System.out.println(list.getLast()); //list.get(list.size()-1);
}
3.removeFirst/removeLast
声明:public Object removeFirst();
作用:删除集合中的首元素，返回的就是删除的这个元素
声明:public Object removeLast()
作用:删除集合中的最后一个元素，返回的是删除的这个元素.
jdk1.6后替换的方法
pollFirst
pollLast
它们区别在于pllFirst/pollLast列表为空时不会产生异常，而是返回null;
注意:对于getFirst/getLast removeFirst/removeLast时，如果集合为空
会产生异常.
//removeFirst removeLast
public static void method3(){
LinkedList list=new LinkedList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.clear();
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println(list);
}
Vector(了解)
Vector是早期应用集合时所使用的一个类.
ArrayList是Vector的替代类.
ArrayList是数组实现，它是每次增加50%,线程不安全.
Vector 是数组实现 它每次拉回100%,线程安全的。
关于使用Enumeration遍历Vector
//1.得到Enumeration对象
Enumeration enu=v.elements();
//2.判断是否有元素可以进行迭代
while(enu.hasMoreElements()){
//3.得到元素
Object obj=enu.nextElement();
System.out.println(obj);
}
List集合的总结
List 有顺序可重复.
|----ArrayList
它的底层实现是使用数组，每次增长50%,在做查询操作时效率高。是线程不安全。
|----LinkedList
它的底层实现是使用链表，它在做修改与删除时效率高。线程不安全。
Linkedlist对于首尾元素操作比较方便.
|----Vector
它的底层实现是数组，每次增长100%,效率低下，线程安全。
对于List集合的遍历方式
1.Iterator
2.get+索引
3.listIterator
Set集合
Set集合:无顺序不可重复
|----HashSet
它是由hash表支持的。这使用hashCdoe与equals来维护元素的唯一
|----TreeSet
对于Set集合，如果想要遍历出所有元素，只能使用迭代器.
元素不重复，是指元素做equals为true,代表重复.
HashSet怎样保证元素唯一
1.两个元素的hashCode不一样，不会判断equals，直接就能装入.
2.两个元素的hashCode一样，equals为false,能装入
3.两个元素的hashCdoe一样，equals为true,不能装入.
做equals相等的对象的hashCode值应该一样.
我们重写hashCode方法时怎样重写
就是将所有的做equals比较进应用的属性的hashCode值进行相加就可以，
为了减少重复的概率，我们可以定义一个质数，用这个质数与
所有的属性相乘，这样使用的hashCode值重复概率减少.
|
收藏
淘帖
踩
