Java学习第十五天--泛型 集合

一 泛型

作用:将数据类型作为参数传递

泛型(可理解为广泛的类型,可代表任何类型)

语法:

        <泛型1,泛型2...>

泛型一般使用大写字母来表示如 K T V X... 

泛型定义的位置:

语法:

        在方法中:

                访问权限修饰符 修饰符 <K,T,V,X...> 返回值类型 方法名(形参列表){

                        方法体

                }

方法中泛型使用位置:1.形参列表 2.方法体 3.返回值类型

        在类中:

                访问权限修饰符 class 类名 <K,T,V,X...>{

                }

        在继承关系中,子类泛型必须包含全部父类泛型,语法为:

                访问权限修饰符 class 子类名 <K,T,V,X...> extends 父类名 <父类泛型>{

                }

类中的泛型在类中各个地方均可使用

注意:在创建对象时必须传入所有泛型类型

        在接口中:

                访问权限修饰符 interface 接口名 <K,T,V,X...>{

                }

        在继承关系中,子接口泛型必须包含全部父接口泛型,语法为:

                访问权限修饰符 interface 子接口名 <K,T,V,X...> extends 父接口名 <父类泛型>{

                }

                访问权限修饰符 class 子类名 <K,T,V,X...> implements 父接口名 <父类泛型>{

                }

接口中的泛型在实现或继承的类或接口,中各个地方均可使用

注意:在创建对象时必须传入所有泛型类型

二 集合

作用:存储一组数据类型相同的数据

集合与数组的区别:

        数组长度固定,不可改变,可以存储基本数据类型与引用数据类型;

        集合长度不固定,可以改变,只能存储引用数据类型.

集合的体系:

Collection(接口)
---List(子接口)
------ArrayList(子类)
------LinkedList(子类)
------Vector(子类)
---Set(子接口)
------HashSet(子类)
------LinkedHashSet(子类)
------TreeSet(子类)
---Queue(子接口,队列)

以上类型的作用与区别:

Collection
        作用:存储数据,操作数据
        特点:无序(存入顺序与取出顺序不一致),无下标
List
        特点:有序(存入顺序与取出顺序一致),有下标,数据可重复
ArrayList:
        数据结构:数组
        特点:查询速度快,增删慢
        线程不安全的
        JDK1.2出现

LinkedList:
        数据结构:链表
        特点:增删快,查询速度慢
Vector:
        数据结构:数组
        特点:查询速度快,增删慢
        线程安全的
        JDK1.0出现

set

        特点:无序,有下标,数据不允许重复
        注意:LinkedHashSet有序
HashSet:
        数据结构:红黑树(二叉树)+哈希表(为了内部排序)
        特点:有自己的排序规则
LinkedHashSet:
        数据结构:红黑树(二叉树)+链表+哈希表(为了内部排序)
        特点:Set家族中唯一一个有序的
TreeSet:
        数据结构:红黑树(二叉树)+自己写排序规则
        特点:可以自定义排序规则

使用方法

        1.创建对象

        2.使用对象调用方法(增删改查)

Collection提供的方法

增:

        boolean add(元素) 数组引用该方法后将元素添加进数组(一个元素) 

        boolean addAll(数组1) 数组引用该方法后将数组1添加进数组(多个元素)

删:

        boolean remove(元素) 数组引用该方法后将数组中的该元素删除(一个元素)

        boolean removeAll(数组1) 数组引用该方法后将数组中所有的数组1的元素全部删除(多个元素)  

        void clear() 数组引用该方法后清理完数组中的全部元素

查:

        int size() 数组引用该方法后返回该数组的长度

        boolean contains(Object o):判断参数中的元素是否在当前集合中存在
        boolean isEmpty():判断集合中是否不存在元素,返回值为true表示当前集合为空集合,反之该结合有存储的元素

数组的遍历: 使用foreach

list提供的方法

包含Collection提供的所有方法
增:
        void add(int index, E element):给指定位置添加数据
                index:指定的位置(位置的索引)
                element:本次添加的数据
        boolean addAll(int index, Collection<? extends E> c):给指定位置插入多个数据
                index:指定的位置(位置的索引)
                c:本次添加的集合
删:
        E remove(int index):删除指定位置的数据
改:
        E set(int index, E element):修改
                index:修改的元素的位置
                element:修改后的元素
查:
        E get(int index):获取指定位置的元素
        int indexOf(Object o):获取元素在集合中的位置,如果不存在返回-1
        int lastIndexOf(Object o):获取元素最后一次出现的位置,如果不存在返回-1

其他:

        List<E> subList(int fromIndex, int toIndex):截取
                 fromIndex:开始位置,包含
                 toIndex:结束位置,不包含
                 返回值:截取出元素的集合

练习:

import java.awt.List;
import java.util.ArrayList;

/*
 * 1,使用集合完成冒泡排序
 */
public class Demo01 {
	public static  void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(10);
		list.add(5);
		list.add(17);
		list.add(6);
		list.add(7);
		list.add(8);
		for (int i = 0; i < list.size()-1; i++) {
			for (int j = 0; j < list.size()-1; j++) {
				if (list.get(j) > list.get(j+1)) {
					int x = list.get(j);
					int y = list.get(j+1);
					list.set(j, y);
					list.set(j+1, x);
				}
			}
		}
		System.out.println(list);
	}
}

import java.util.ArrayList;

/*
 * 使用集合模拟栈与队列
栈(水桶):先进后出(取出后没有了)
队列(水管):先进先出(取出后没有了)
 */
public class Demo02 {
	public static void main(String[] args) {
		ArrayList<Integer> list01 = new ArrayList<Integer>();//队列
		ArrayList<Integer> list02 = new ArrayList<Integer>();//栈
		list01.add(15);
		list01.add(16);
		list01.add(4);
		list01.add(46);
		list02.addAll(list01);
		while (!list01.isEmpty()) {
			list01.remove(list01.size()-1);	
		}
		while (!list02.isEmpty()) {
			list02.remove(0);
		}
		System.out.println(list01);
		System.out.println(list02);
	}
}

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

/*
 * 分别使用3种方式遍历ArrayList
 */
public class Demo03 {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(15);
		list.add(16);
		list.add(1);
		list.add(9);
		list.add(4);
		list.add(17);
		for (Integer integer : list) {
			System.out.print(integer+" ");
		}
		System.out.println();
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i)+" ");
		}
		System.out.println();
		Iterator it = list.iterator();
		while (it.hasNext()) {
			System.out.print(it.next()+" ");
		}
	}
}