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 类名<泛型类型1,泛型类型2……>{
泛型类型 变量名；
泛型类型 方法名(){}
返回值类型 方法名(泛型类型 变量名){}
}
使用带泛型的类：
类名<具体类> 对象名 = new 类名<具体类>();
类型参数规范：推荐使用规范-常见的泛型,泛型只保存在源文件中,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);
}
相关推荐
尚硅谷_JavaSE_第12章_集合与泛型_扩展练习_附带参考答案.md
学习这部分内容对于Java开发者至关重要，因为理解并熟练掌握Java集合框架和泛型，能有效地提升代码质量和效率，减少运行时错误。此外，了解枚举类型有助于编写更安全、更整洁的代码。通过深入研究和实践，开发者能够...
BDQN ACCP 7.0 Java《集合框架及泛型》学习资料.part1
在实际开发中，理解和熟练运用Java集合框架和泛型能够大大提高代码的可维护性和安全性，减少类型转换的麻烦，并使得代码更易于理解和复用。通过以上讲解，相信你已经对这两个主题有了更深入的理解。通过练习和应用，...
Java 泛型是Java编程语言中的一个重要特性，它在JDK 5版本中引入，显著提高了代码的类型安全性和重用性。泛型允许程序员在类、接口和方法中使用类型参数，使得容器（如ArrayList、LinkedList等）可以保存特定类型的...
通过学习和练习这些内容，你可以深入理解Java集合框架的核心概念和泛型的应用，从而在编程实践中更加灵活和高效地处理数据。同时，不断的学习和实践是提升技能的关键，希望你能在Java世界中不断进步。
2. **避免装箱和拆箱**：对于值类型（如 int），使用泛型可以直接操作这些类型而无需装箱和拆箱，从而提高了性能。 3. **代码重用**：一个泛型类或方法可以被用于多种类型，减少了代码重复。 #### 五、泛型约束 有...
**集合框架与泛型**是Java编程语言中的核心特性，对于初学者来说，理解并熟练掌握这两个...结合提供的课件“第六章 集合框架与泛型.ppt”，初学者可以通过系统学习和实践，进一步提升对Java高级特性的理解和应用能力。
69 026_2默认泛型参数与运算符重载.mp4
1. **泛型**：泛型是Java 5引入的最重要的特性之一，它允许在类、接口和方法中使用类型参数，从而实现了类型安全的集合操作。泛型的主要优点是避免了类型转换的麻烦，消除了运行时的类型异常。例如，ArrayList可以...
### Delphi 泛型使用全集（队列_栈_字典_列表_对象列表） #### 一、泛型概述 在 Delphi 中，泛型编程允许开发人员编写灵活且可重用的...通过这些示例，你可以了解到如何在 Delphi 应用程序中有效地使用这些泛型集合。
集合框架与泛型是Java编程语言中的核心概念，它们极大地提高了代码的可读性、安全性和效率。在Java中，集合框架是一组接口和类，它们提供了存储和操作对象的统一方式。泛型则是Java 5引入的一个特性，用于在编译时...
day14_Collection、泛型、简单数据结构、List.pdf
详细的介绍了集合框架的用法，及其语法规则，剖析了使用的使用注意事项，帮助更牢靠的掌握集合框架的知识及泛型内容。谢谢
《GP-泛型算法通则》是一份深入探讨GP（Genetic Programming）算法与泛型编程相结合的资源包。...通过深入学习和实践，你将能够熟练地运用GP算法解决复杂问题，并利用泛型编程提高代码质量和效率。
简单介绍 里氏替换原则 简单工程模式 实现任意排序 使用了 is 和 as 方法 ArrayList数组 与 List泛型集合 Hashtable数组 与 Dictionary,v>泛型集合 的基本使用 序列化 将数据存储
在集合框架中，泛型机制的引入则进一步提升了类型安全性和代码的简洁性。 首先，让我们深入了解一下Java集合框架。集合框架包含了多种类型的容器，如List、Set和Queue等，它们各自有不同的特性以满足不同场景的需求...
这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”...
Java集合框架是Java编程语言中的一个核心...通过学习Java集合框架，开发者能够更好地理解和利用这些工具来设计高效、可维护的程序，提高代码质量。这个课件将帮助你掌握这些关键概念，并提供实践操作的机会，加深理解。