Collection_util

 

集合框架的工具类Collections   Arrays

 

一、Collections这个类是专门对集合进行操作的工具类；

 

Collections的特点：里面的方法都是静态的；他没有对外提供构造函数，是不需要创建对象的；因为他的对象并未没有封装特有的数据；都是共享的情况，所以定义在静态最方便；

 

有一堆元素，不需要保证里面的唯一性，一般用List集合；

 

因为是静态类，所以类型上不能定义在类上，只能定义在方法上；

 

排序方法sort 是给list集合排序的；

public static <T extends Comparable<?super T>> void sort(List<T> list)

加泛型的目的就是为了让在编译和在编译时期具备比较性；所以必须要注意进行泛型限定；

 

因为list是数组结构，所以里面可以出现重复情况；数组结构是有脚标索引的，而set集合没有脚标索引，所以不能重复，重复就搞不清楚哪个是哪个了；

 

比较有两种思路，第一，直接元素内部比较，第二，引入一个比较器进行比较；

 

凡是要进行对象比较，就必须要用到这两个接口，compare或者compareTo

 

max（）方法

public static <T extends Object &Comparable<? super T>> T max(Collection<? extends T> coll)

 

二分法查找；

binarySearch(List<? extendsComparable<? super T>> list, T key)

用到这个方法必须第一是list集合，要有脚标才行，第二必须要是有序集合才行；

 

copy（）方法

 

 

fill(List<? super T> list, T obj)方法

将集合中的元素全都替换为某一个值；

练习：fill方法可以就爱那个list集合中的所有元素替换成指定元素，

将list元素中，部分元素替换成指定元素；

 

replaceAll方法   使用另一个值替换列表中出现的所有某一指定值。

 

reverse方法：反转指定列表中元素的顺序。

原理就是交换位置；

 

reverseOrder()

         返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

reverseOrder(Comparator<T> cmp)

         返回一个比较器，它强行逆转指定比较器的顺序。

 

集合中那么多的对象，他们都有一个共同的特点，就是线程不安全，因为高效；

所以就要进行加锁；

 

集合的安全问题；可以把非同步的变成同步的；

static <T> Collection<T>

 synchronizedCollection(Collection<T> c)

         返回指定 collection 支持的同步（线程安全的）collection。

static <T> List<T>

 synchronizedList(List<T> list)

         返回指定列表支持的同步（线程安全的）列表。

static <K,V> Map<K,V>

 synchronizedMap(Map<K,V> m)

         返回由指定映射支持的同步（线程安全的）映射。

static <T> Set<T>

 synchronizedSet(Set<T> s)

         返回指定 set 支持的同步（线程安全的）set。

 

 

swap(List<?> list, int i, int j)

         在指定列表的指定位置处交换元素。  

 

shuffle(List<?> list)

         使用默认随机源对指定列表进行置换。

 

把集合中的元素重新随机的排序；

 

 

二、Arrays：用于操作数组的工具类；里面都是静态的方法：

 

首先是二分查找，集合和数组都可以进行二分查找；

 

一系列的比较equals方法；

 

深度比较，可以比较数字里面的对象或者元素里的内容；

 

将数组变成List集合；

asList(T... a)  返回一个受指定数组支持的固定大小的列表。

 

把数组变成List集合有什么用途？

 

可以使用集合的思想和方法来操作数组中的元素；要不然就要自己封装方法；

 

数组是一个对象，但是功能比较少，集合的方法比较多；

 

注意，将数组变成集合，不可以使用集合的增删方法；因为数组的长度是固定的；

 

否则就发生不支持操作异常；

 

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素；如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在；

（我在想，如果是基本类型，然后我在集合后面加泛型为包装类，会不会正常呢？）

 

将集合变成数组

Collection的toArray方法

指定类型的数组到底要定义多长呢？

当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size；

当指定类型的数组长度大于了集合的size，就不会创建了数组，而是使用传递进来的数组；

所以创建一个刚刚好的数组最优，就不需要再创建一个数组，占用内存；

 

为什么要将集合变数组呢？

为了限定对元素的操作；避免对方接收集合后对该集合进行增删动作；

 

高级for循环

格式

         for（数据类型  变量名 ： 被遍历的集合（Collection）或者数组）

底层原理还是迭代器，只是把复杂代码变成了简单代码，这个升级只是为了简单书写；

这个循环只能对集合进行取出功能，不能进行修改；

迭代器还可以进行remove，如果是列表迭代器，还可以进行增删改查；

 

for循环；对集合进行遍历，只能获取元素，不能对集合进行操作；

迭代器除了遍历，还可以进行remove集合中的元素的动作；

如果是用ListIterator，还可以在遍历的过程中对集合进行增删改查的动作；

高级for循环也可以使用于数组；

 

传统for循环和高级for循环有一个局限性，必须有被遍历的目标；

 

建议在遍历数组的时候，还是希望使用传统for循环，因为传统for循环可以定义脚标；

 

凡是支持迭代器的集合都支持高级for循环；map就必须先转为set才行；

 

注意，集合之后只要是对象必须要加泛型，只要是1.5版本的，就必须要加泛型；

 

JDk1.5版本出现的新特性；

可变参数的特点：

public static void show （int。。。arr）

可变参数，就是用一个数组参数的简写形式，不需要手动的建议多个数组对象，或者建立多个方法就可以重载多个参数类型一样的方法；只需要传入元素即可，传几个就生成几个元素的数组；

只要将要操作的元素作为参数传递即可，隐式的将这些参数封装成了数组；简化了书写，提高开发效率；

 

注意：在使用方法的可变参数的这种新特性时，可变参数一定要定义在参数列表的最后面；

如void show（string str ，int。。。arr）

 

静态导入：

 

导入一个类中的所有静态成员；

 

如，import static java.util.Arrays.*；  导入的是Arrays这个类中的所有静态成员；

 

当类名重名时，需要指定具体的包名，当方法重名时，执行具体所属的对象或者类；

尤其注意和Object类中的方法重名时，即重写了Object类的方法，要注意，要注意标明；

 

import static java.lang.System.*;导入了System类中的所有静态成员；

 

没有写静态，导入的都是类，写了静态后，导入了是某一个类中的所有成员；