---
title: "黑马学习日记_集合框架泛型和collections"
author: "小驴变黑马"
date: "2014-04-25T10:25:13Z"
tags: []
categories: ["编程语言"]
slug: "collections"
draft: false
lastmod: "2014-04-25T10:25:13Z"
id: 2041491
url: "https://itheima.iteye.com/blog/2041491"
---

---------------------- [android开发](http://www.itheima.com/)、[java培训](http://www.itheima.com/)、期待与您交流！ ----------------------

1、Collections类

操作集合的工具类：

static void reverse(List list):反转指定List集合中的顺序；（和ListItertor的逆序排列一样！）

static void shuffle(List list):对集合元素随机排序

static void sort(List list):自然升序排序

static vois swap(List list,int i, int j):将指定的List集合i处元素和j处元素进行交换；

static void rotate(List list, int distance):

若distance为正数，将list集合后的distance个元素移到前面；

当distance为负数，将list集合前的distance个元素移到后面；

static  int binarySearch(List list, Object key) 使用二分搜索法搜索指定列表，以获得指定对象。 

调用之前 必须调用 Collections.sort(List list)(完成自然排序);

 

static Object max(Collection coll) 根据元素的自然顺序，返回给定 collection 的最大元素。   

static Object min(Collection coll) 根据元素的自然顺序，返回给定 collection 的最小元素。  

static  void fill(List list, Object obj)  使用指定元素替换指定列表中的所有元素。

static int frequency(Collection c, Object o)  返回指定 collection 中等于指定对象的元素数。 

static int indexOfSubList(Listsource, List target) 返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。 

static int lastIndexOfSubList(List source, List target)  返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。

static boolean  replaceAll(List list, Object oldVal, Object newVal)  使用另一个值替换列表中出现的所有某一指定值。

同步集合 

 

Eg：

import static java.util.Collections.binarySearch;

import static java.util.Collections.shuffle;

import static java.util.Collections.sort;

 

import java.util.ArrayList;

import java.util.List;

 

public class CollectionsDemo {

public static void main(String\[] args) {

List list = new ArrayList();

list.add(1);

list.add(-3);

list.add(5);

list.add(-99);

 

System.out.println(list);

sort(list);

System.out.println(list);

int index = binarySearch(list, 0);

System.out.println(index);

 

System.out.println("好的顺序" + list);

shuffle(list);

System.out.println("随机" + list);

 

}

}

 

2、Arrays

 

public static  List asList(Object... a)返回一个受指定数组支持的固定大小的列表(返回的是不可变的List(长度固定))。

（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。 

此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素： 

List list= Arrays.asList("Larry", "Moe", "Curly");

list.add("Will");×

 

Eg：

import java.util.Arrays;

import java.util.List;

 

 

public class ArraysDemo {

public static void main(String\[] args) {

List list = Arrays.asList("will","Lucy","小强");

System.out.println(list);

list.set(0, "你好");

//list.add("22");//错误，返回一个受指定数组支持的固定大小的列表。不可以再添加！

//list.remove(0);

System.out.println(list);

}

}

 

 

3、泛型(Generic)

引入：我想使用List集合装公司的员工，却装了一条狗进来；

使用TreeSet的时候,只能存放同一种数据类型,可惜存了不同的数据类型,依然没有报错,可是运行时出错.

 

泛型定义：

　　java5开始出现的一种对Java语言类型的一种拓展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数类型时指定的类型占位符,就好比方法的形式参数是实际参数的占位符一样.

　　泛型能保证大型应用程序的类型安全和良好的维护性;

 

使用泛型的优势:

　　类型安全,使编译器对泛型定义的类型做判断限制.如保证TreeSet里的元素类型必须一致;消除强制类型的转换,如,使用Comparable比较时每次都需要类型强转；

　　

4、泛型的使用

 

泛型类

 

在类声明时通过一个标识符表示类中某个字段的类型或者某个方法的返回值或参数的类型，这样在类声明或实例化的时候只要指定自己需要的类型就ok。

 

声明带泛型的类:

class 类名&lt;泛型类型1,泛型类型2……&gt;{

泛型类型  变量名；

泛型类型  方法名(){}

返回值类型 方法名(泛型类型 变量名){}

}

使用带泛型的类：

类名&lt;具体类&gt; 对象名 = new 类名&lt;具体类&gt;();

 

类型参数规范：推荐使用规范-常见的泛型,泛型只保存在源文件中,class文件中不存在;也就是说在编译阶段就会丢失,基本数据类型不能作为泛型类型;

K 键，比如映射的键  key的类型

V 值，比如Map的值 value类型

E 元素，比如Set  Element表示元素,元素的类型

T 泛型，Type的意思

 

总结：泛型好处：限定添加类型和消除强转转换的麻烦！

 

泛型使用

 

public class Point { //声明任意符号的标识符

private Q x; //变量类型由外部组成

private Q y;

public Q getX() {

   return x;

}

public void setX(Q x) { //类型由外部决定

   this.x = x;

}

//..........................

}

 

.................main.........

{

Point p = new Point(); //定义具体类型

p.setX(1.1);

p.setY(2.2);

}

 

练习例子

需求：设计一个表示点的类Point,该类有两个字段，一个是横坐标x,一个纵坐标y,要求坐标有3种表达形式（Integer，Double，String）：

 

如果不使用泛型的话可以新建多个类，但是内部方法体只有参数类型不一样，所以用泛型的话更加简单，给定一个占位符，并不明确表示到底是什么类型，在实际运用的时候才确定类型！！

 

很好的例子！

package generic;

 

class Point{

private T t1;

private T t2;

public T getT1() {

return t1;

}

public void setT1(T t1) {

this.t1 = t1;

}

public T getT2() {

return t2;

}

public void setT2(T t2) {

this.t2 = t2;

}

}

 

public class GenericDemo {

public static void main(String\[] args) {

//String 类型的

Point p = new Point();

p.setT1("2");

p.setT2("3");

System.out.println(p.getT1());

System.out.println(p.getT2());

//Integer 类型的

Point p2 = new Point();

p2.setT1(23);

p2.setT2(24);

System.out.println(p2.getT1());

System.out.println(p2.getT2());

//Double 类型的

Point p3 = new Point();

p3.setT1(23.00);

p3.setT2(24.00);

System.out.println(p3.getT1());

System.out.println(p3.getT2());

\-----------------------------------------------------------------------------------------------------------------------------------------------

Set s = new HashSet();//创建一个容器对象,应该在创建的时候就明确是装什么的

s.add("a");

//s.add(1);//此时就加不进去了，因为已经限制了容器内参数类型！

//此时就能保证集合里元素类型一致,

Set treeSet = new  TreeSet();

//规定key只能是String,value是Date

Map map = new HashMap();

// V put(K key, V value) 

Date v = map.put("", new Date());//和上面定义的类型一样

//V get(Object key)  

Date val = map.get("");

}

}

 

运行结果

2

3

23

24

23.0

24.0

这样的话借助泛型一个类就可以表达多个不同类型的参数！

 

要求

消除强制类型的转换,如,使用Comparable比较时每次都需要类型强转;

 

1、没有加上泛型，最初的需要强制类型转换

 

package generic;

 

import java.util.Set;

import java.util.TreeSet;

 

class Person implements Comparable{//需要进行排序的类要实现Comparable

private Integer age;

public Person(Integer age) {

super();

this.age = age;

}

@Override

public int compareTo(Object o) {

Person p = (Person)o;//强制类型转换

return this.age.compareTo(p.age);

}

public String toString(){

return this.age.toString();

}

}

 

public class GenericDemo2 {

public static void main(String\[] args) {

Set set = new TreeSet();

set.add(new Person(15));

set.add(new Person(12));

set.add(new Person(19));

set.add(new Person(53));

set.add(new Person(62));

System.out.println(set);

}

}

第二步：加上泛型，不再需要强转（因为类型已经固定了）！

 

package generic;

 

import java.util.Set;

import java.util.TreeSet;

 

class Person implements Comparable{//

private Integer age;

public Person(Integer age) {

super();

this.age = age;

}

@Override

public int compareTo(Person o) {

return this.age.compareTo(o.age);//按照什么排序

}

public String toString(){

return this.age.toString();

}

}

 

public class GenericDemo2 {

public static void main(String\[] args) {

Set set = new TreeSet();

set.add(new Person(15));

set.add(new Person(12));

set.add(new Person(19));

set.add(new Person(53));

set.add(new Person(62));

System.out.println(set);

}

}

 

5、声明多个泛型类型和通配符

 

若一个类中多个字段需要不同的泛型声明，则在声明类的时候指定多个泛型类型即可；

 

格式：

public interface IDAO {

PK add(T t);

 

void remove(PK id);

 

void update(PK id, T t);

 

T get(PK id);

}

---------------------- [android开发](http://www.itheima.com/)、[java培训](http://www.itheima.com/)、期待与您交流！ ----------------------