黑马程序员_Collection集合之List

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流------

 1. ArrayList: 底层是数组的实现, 查询快 , 增删慢
   线程不安全的,效率高

//举例:如何使用ArrayList去除集合中的重复的自定义对象

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

//如何使用ArrayList去除集合中的重复的对象
public class ArrayListTest {

	public static void main(String[] args) {
		
		//创建ArrayList集合对象
		ArrayList al = new ArrayList();
		
		//向集合中添加元素
		al.add("三笠");
		al.add("艾伦");
		al.add("爱尔敏");
		al.add("三笠");
		al.add("艾伦");
		
		//创建新的ArrayList集合接受数据
		ArrayList newal = new ArrayList();
		//使用set跟get集合遍历集合
		for (int i = 0; i < al.size(); i++) {
			String str = (String)al.get(i);
			
			if (!newal.contains(str)) {
				newal.add(str);
			}
		}
		
		//使用迭代器遍历newal集合
		Iterator it = newal.iterator();
		while (it.hasNext()) {
			String result = (String) it.next();
			System.out.println(result);
		}
	}
}

2.泛型的定义以及应用

 在编写这些代码的时候都会有黄色警告线,那么我们应该这么处理呢?为此java为我们提供了泛型
 
 泛型: 就是一种把指定数据类型的工作推迟到创建对象或者调用方法的时候的特殊的类型 , 是一种参数化类型
 	格式:
 		
    
    <数据类型>
     
     
 		数据类型: 必须是引用数据类型
 
 	泛型的好处:
 		a: 把运行期的错误提前到了编译期
 		b: 省去了向下转型
 		c: 去掉了黄色警告线
 
 泛型方法: 就是把泛型定义在方法上
	格式:    修饰符 泛型 返回值类型 方法名(泛型类型 变量名){}
 泛型接口: 就是把泛型定义在接口上
 	格式:		public interface 接口名
     
     <数据类型>
      
       {}
 
 泛型的注意事项:
 	1. 如果泛型明确了以后,左右两边必须一致
 	2. ? 表示的任意的意思
 	3. ? extends E : 向下限定,表示的是E或者E的子类
 	4. ? super   E : 向上限定 , 表示的是E或者E的父类
     
     
    
    

3. 可变参数

可变参数的格式:
		修饰符 返回值类型 方法名(数据类型... 变量名){
  
  		} 
  
 	可变参数的注意事项:
 		如果一个方法上定义了可变参数,那么这个可变参数必须是该方法的最后一个参数
 

可变参数的应用

//举例:我要编写一个方法,但是我不知道这个方法要接收几个参数,但是在调用的时候,我就可以知道了,怎么办? 可以使用可变参数完成
 
 class ArgsTest{
 
 	public static void main(String[] args){
 		
 		//调用add方法并输出结果
 		System.out.println(add(10, 20)) ;
 		System.out.println(add(10, 20, 30)) ;
 		System.out.println(add(10, 20, 30, 40)) ;
 		
 	}
 	
 	public static int add(int... a){
		
		int sum = 0 ;
		
		//由于可变参数的本质是一个数组,我们使用加强for遍历数组
		for (int i : a) {
			sum += i ;
		}
		
		return sum ;
	}
 }

4. 练习:ArrayList集合的嵌套使用:

/*
练习:	我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList
     
     
      
      
	但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList
      
      
       
       。	
	而我现在有多个ArrayList
       
       
        
        。也要用集合存储，怎么办呢?
	
集合嵌套之ArrayList嵌套ArrayList
*/

//定义一个Student类
public class Student {

	private String name ;
	
	private int age ;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Student() {
		super();
	}
	
}

//嵌套ArrayList类

import java.util.ArrayList;

public class ArrayListTest {

	public static void main(String[] args) {
		
		//创建对象
		ArrayList
        
        
         
         
           > al = new ArrayList 
           
           
             >(); //创建第一个班级class1的对象 ArrayList 
            
              class1 = new ArrayList 
             
               (); //创建学生对象 Student s1 = new Student("刘备" , 30); Student s2 = new Student("关羽" , 28); Student s3 = new Student("张飞" , 26); //添加元素 class1.add(s1); class1.add(s2); class1.add(s3); //添加到集合al中 al.add(class1); //创建第二个班级class2的对象 ArrayList 
              
                class2 = new ArrayList 
               
                 (); //创建学生对象 Student s4 = new Student("杨过" , 20); Student s5 = new Student("小龙女" , 26); //添加元素 class2.add(s4); class2.add(s5); //将class2添加到al中 al.add(class2); //遍历 for (ArrayList 
                
                  classList : al) { for (Student s : classList) { //输出学生成员 System.out.println(s.getName() + "----" + s.getAge()); } System.out.println("---------------"); } } } 
                 
                
               
              
             
            
           
         
        
        
       
       
      
      
     
     

5.Vactor集合的概述:

Vector: 底层是通过数组实现的,查询快 , 增删慢
  		      线程安全的 , 效率低
  我们常用的方法有:
  		public void addElement(E obj):		添加元素
		public E elementAt(int index):		获取指定索引对应的元素
		public Enumeration elements():		一个特殊的遍历方式	

使用以上特殊方法对Vactor集合进行遍历

import java.util.Enumeration;
import java.util.Vector;
//使用特殊的遍历方式遍历Vector集合
public class VectorTest {

	public static void main(String[] args) {
		
		//创建Vector集合对象
		Vector
      
      
       
        v = new Vector
       
       
        
        ();
		
		//添加元素
		v.addElement("hello");
		v.addElement("world");
		v.addElement("java");
		
		//创建迭代器对象
		Enumeration
        
        
         
          en = v.elements();
		
		//遍历
		while (en.hasMoreElements()) {
			String s = en.nextElement();
			
			//输出
			System.out.println(s);
		}
	}
}
 
        
        
       
       
      
      

6. LinkedList集合的特点:

LinkedList: 底层靠链表实现,查询慢 , 增删快
 			   线程不安全 , 效率高
  		public void addFirst(E e):		在第一个位置添加元素
  		public void addLast(E e):		将指定元素添加到此列表的结尾。 
		public E getFirst():			获取第一个元素
		public E getLast():				获取最后一个元素
		public E removeFirst():			移除第一个元素
		public E removeLast():			移除最后一个元素

7.List集合下的三个子类的特点:

则这三个集合的的特点总结:
 ArrayList
	底层是靠数组实现的:	查询快, 增删慢
	线程不安全 , 效率高
Vector
	底层是靠数组实现的:	查询快, 增删慢
	线程安全 ,效率低
LinkedList
	底层是靠链表实现的:	查询慢, 增删快
	线程不安全 , 效率高