17-集合(一),List接口,泛型

17-集合:Collection,List,ArrayList,LinkedList

集合(Collection):
- 集合提供了一整套性能优良,使用方便的接口和类位于java.util
集合可以看作是一个可变的容器,也可以看作是一个可变的数组

增: add(E e), addAll(Collection c)

删: clear(), remove(Object o), removeAll(Collection<?> c), retainAll(Collection<?> c)

改: toArray()

查: iterator() , size()

判断: contains(Object o), containsAll(Collection c) , isEmpty()

注意: 集合中所有的数据都是object的

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {
	public static void main(String[] args) {
		//[1]创建对象
		Collection c1 = new ArrayList();			//父类new子类   多态
		Collection c2 = new ArrayList();			
		
		//[2]添加
		c1.add("清子");			//添加单条数据		Object obj = new String();
		c1.add("九日");
		c1.add(12);		//Object obj = new Integer;
		c1.add('男');
		c2.add("青删");
		c1.addAll(c2);
		System.out.println(c1);			//toString()
		System.out.println(c2);
		
		//[3]判断
		System.out.println("集合是否为空:"+c1.isEmpty()+",长度为:"+c1.size());
		System.out.println("一个集合当中是否包含指定的元素:"+c1.contains("青删"));
		System.out.println(c1.containsAll(c2));  //c1中包含c2中所有的元素则返回true
		
		//[4]查询
		System.out.println("集合的遍历.....foreach");
		for(Object obj : c1) {
			System.out.print(obj+"\t");
		}
		System.out.println("\n集合的遍历....iterator()");
		Iterator it = c1.iterator();		//调用方法,方法的结果it  是iterator类型
		while(it.hasNext()) {			//判断下一个是否有元素
			Object obj = it.next();			//取出一个元素,同时会下移一位
			System.out.print(obj+"\t");
		}
		
		//[5]修改
		Object[] obj = c1.toArray();		//转为数组
		for(int i=0;i<obj.length;i++) {
			System.out.print(obj[i]);
		}
		
		//[6]删除
		System.out.println("====================");
		//c1.clear();
		//c1.remove(12);
		System.out.println(c1);
		System.out.println(c2);
		//c1.removeAll(c2);    //从集合c1中删除与c2相同的元素
		c1.retainAll(c2);    //从集合c1中删除与c2不同的元素
		System.out.println(c1);
		System.out.println(c2);
	}
}

List接口: 有序(插入数据的顺序), 不唯一(可重复的) —>索引
- 增: add(int index, E element) , addAll(int index, Collection<? extends E> c)
- 删: remove(int index)
- 改: set(int index, E element)
- 查: get(int index), indexOf(Object o)
- 其他: subList(int fromIndex, int toIndex)
ArrayList:

在增删改查上没有自己的特有的方法

两个实现类:

ArrayList:

长度可变的数组,在内存中连续的空间

优点: 遍历和随机访问效率高

缺点: 添加和删除效率低

LinkedList:

采用了链表的存储方式

优点: 插入,删除元素的效率比较高

缺点: 遍历和随机访问的效率比较低

import java.util.ArrayList;
import java.util.List;
public class ListDemo {

	public static void main(String[] args) {
		//[1]创建对象
		List list = new ArrayList();
		List list1 = new ArrayList();
		
		//[2]添加
		list.add("国东");
		list.add(0, 111);   //在指定下标位置上添加数据
		System.out.println(list);
		list1.add("乌龟");
		list1.add("可乐");
		list.add(0, "啦啦啦");  
		list.addAll(0, list1); //在指定下标位置上添加一个集合的数据
		
		System.out.println(list);
		
		//[3]删除
		list.remove(1);
		System.out.println(list); 
		
		//[4]修改
		list.set(0, "灼灼");
		System.out.println(list); 
		
		//[5]查看
		System.out.println("根据素银获取指定位置上的元素:"+list.get(0));
		System.out.println("根据对象查找下标:"+list.indexOf("国东"));   //找到返回下标 找不到返回-1
		System.out.println("==========遍历====================");
		for(int i = 0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		
		//[6]其他 (截取一个小集合)
       System.out.println(list);
       List newList = list.subList(1, 3);
       System.out.println(newList);   //包含开始,不包含结束
       System.out.println(list);
	}
}

linkedList:
- 增: addFirst(E e) ,addLast(E e) -->1.2
  - ```
    	offerFirst(E e) offerLast(E e)    -->1.6
```
  offer(E e) --1.5
- ```
  删:removeFirst() ,removeLast()     --1.2
```
  pollFirst() pollLast() --1.6
- poll() 1.5
- 改:
- 查: getFirst() ,getLast() 1.2
- peekFirst() peekLast() 1.6
- peek() 1.5

import java.util.LinkedList;
public class LinkedListDemo {

	public static void main(String[] args) {
		//创建对象
		LinkedList  list = new LinkedList();
		
		//[2]添加
		list.add("落天");
		list.addFirst("曾凯");
		list.addLast("AM");
		System.out.println(list);
		
		//[3]删除
		Object obj = list.removeFirst();
		System.out.println(obj);
	    list.removeLast();
		System.out.println(list);
		
		//[4]查询
		System.out.println("取出头元素;"+list.getFirst());
		System.out.println("取出尾元素;"+list.getLast());
		
		
		//版本测试:
		list.clear();
		//System.out.println("取出头元素;"+list.getFirst());   //1.2
		System.out.println("取出头元素;"+list.peekFirst());    //1.6
		
	}
}

泛型: < >

集合中数据在存储的时候,元素的类型为object

泛型是指在声明时就确定数据类型,不正确的数据类型不允许存入集合

好处:

解决了数据类型不统一的问题

泛型的表现形式:

1.泛型类: 定义在类上

2.泛型方法: 定义在方法上

3.泛型接口: 定义在接口上
泛型类,方法

public class Fun<T> {   //T是type的简写   相当于占位符    具体是什么类型,创建的对象的时候决定
	private T t;    //私有的属性

	public Fun(T t) {    //在整个类中所有的t都表示同一种数据类型
		super();
		this.t = t;
	}

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}
	public <T> void show(T t) {   //解决了参数个数相同情况下的方法重载
		System.out.println(t);
	}
	public <Q> void show(Q q,T t){   //   
		
	}
}

public class FunDemo {
	  public static void main(String[] args) {
		//创建ArrayList对象,数据类型设置为Integer
		  ArrayList<Integer> list1 = new ArrayList<Integer>();
		  list1.add(23);
		  list1.add(12);
		  list1.add(11);    //运行时异常编程了编译时异常.
		  //遍历
		  for(Integer i: list1){
			  System.out.println(i);
		  }
		  
		  //使用自定义类型泛型创建对象定义FUN 为String类型并赋值
		  Fun<Integer> f1 = new Fun<Integer>(12);
		 
		  f1.show("风雨");  //String
		  f1.show(12);       //Integer
		  f1.show(11.1);   //Double	  
	}
}

泛型接口

public interface MyInterface<A> {   //泛型

}
class myIn<A> implements MyInterface<A>{   
	//泛型接口的实现类,实现类中泛型的数据类型 依旧不确定
}
class myInt<String> implements MyInterface<String>{   
	//泛型接口的实现类,实现类中泛型的数据类型确定为String类型
}

17-集合(一),List接口,泛型

17-集合:Collection,List,ArrayList,LinkedList

猜你喜欢