Collections工具类——sort方法
一、概述
Collections工具类，完全由在 collection 上进行操作或返回 collection 的静态方法组成。
1.根据元素的自然顺序 对指定列表按升序进行排序。
static <T extends Comparable<? super T>> void sort(List<T> list)
2.根据指定比较器产生的顺序对指定列表进行排序。
static <T> void sort(List<T> list, Comparator<? super T> c)
二、代码
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
}
public static void sortDemo()
{
ArrayList<String> l=new ArrayList<String>();
l.add("adac");
l.add("sawwa");
l.add("ccd");
l.add("qq");
l.add("qq");//可以添加重复元素，因为是数组结构，有角标。
l.add("kk");
sop(l);
Collections.sort(l);//把List集合中的元算，按照元素自身的比较方法进行排序。
sop(l);
Collections.sort(l,new StrLenComparator());//指定比较器的排序方式
sop(l);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
Collections——max方法
一、max()方法
1.根据元素的自然顺序，返回给定 collection 的最大元素。static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
2.根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
二、代码
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
}
public static void sortDemo()
{
ArrayList<String> l=new ArrayList<String>();
l.add("adac");
l.add("zawwa");
l.add("ccaassd");
l.add("qq");
l.add("qq");
l.add("kk");
sop(l);
String max1=Collections.max(l);//根据Collection中元素自带的比较方式，取出里面的最大元素。
sop(max1);
String max2=Collections.max(l,new StrLenComparator());//根据自定义的比较器，取出Collection集合中的最大元素。
sop(max2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
Collections——binarySearch、fill、replace方法
一、概述1.binarySearch()方法(折半查找)1.1使用二分搜索法搜索指定列表，以获得指定对象。
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
1.2使用二分搜索法搜索指定列表，并指定比较器，以获得指定对象。
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
2.fill()方法
2.1使用指定元素替换指定列表中的所有元素。
static <T> void fill(List<? super T> list, T obj)
3.replaceAll()
3.1使用另一个值替换列表中出现的所有某一指定值。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
二、代码 1.binarySearch()方法(折半查找)
public static void binarySearchDemo()2.fill()方法
{
ArrayList<String> l=new ArrayList<String>();
l.add("adac");
l.add("zawwa");
l.add("ccaassd");
l.add("qq");
l.add("qq");
l.add("kk");
Collections.sort(l);
sop(l);
int index=Collections.binarySearch(l,"adac");//如果找到指定数据，则返回所在集合的位置。
int index1=Collections.binarySearch(l,"adacd");//如果找的数据不存在，则会返回-(插入点)-1
sop("index:"+index);
sop("index:"+index1);
}
public static void fillDemo()
{
ArrayList<String> l=new ArrayList<String>();
l.add("adac");
l.add("zawwa");
l.add("ccaassd");
l.add("qq");
l.add("qq");
l.add("kk");
sop(l);
Collections.fill(l,"bb");
sop(l);
}
Collections——reverse()、reverseOrder()方法
一、概述1.reverse()1.1反转指定列表中元素的顺序。
static void reverse(List<?> list)
2.reverseOrder()
2.1返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder()
2.2返回一个比较器，它强行逆转指定比较器的顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
二、代码
import java.util.*;
class CollectionsDemo2
{
public static void main(String[] args)
{
orderDemo();
}
public static void orderDemo()
{
/*①*/TreeSet<String> l=new TreeSet<String>(new StrComparator());//自定义一个比较器来反向排序元素
/*②*/TreeSet<String> l=new TreeSet<String>(Collections.reverseOrder());//使用reverseOrder方法直接将元素反向排序
/*①和②的结果相同*/
//TreeSet<String> l=new TreeSet<String>(new StrLenComparator());//按照长度排序
TreeSet<String> l=new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));//将上一行代码的排序规则强行逆转，改成长的字符串在最上面。
l.add("adac");
l.add("zawwa");
l.add("ccaassd");
l.add("qqz");
l.add("qqasda");
l.add("kk");
Iterator<String> it=l.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class StrComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
return s2.compareTo(s1);
}
}
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
Collections——synchronizedXxx、swap、shuffle方法
一、概述1.synchronizedXxx()方法1.1返回指定列表支持的同步（线程安全的）列表。
static <T> List<T> synchronizedList(List<T> list)
1.2返回由指定映射支持的同步（线程安全的）映射。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
1.3返回指定 set 支持的同步（线程安全的）set。
static <T> Set<T> synchronizedSet(Set<T> s)
2.swap()方法
2.1在指定列表的指定位置处交换元素。
static void swap(List<?> list, int i, int j)
3.shuffle()方法————(比如筛子，扑克牌)
3.1使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list)
Arrays工具类
一、概述 Arrays:用于操作数组的工具类，里面都是静态方法，具体使用方法参加jdk，这里只简单介绍asList方法1.asList()方法
返回一个受指定数组支持的固定大小的列表。
static <T> List<T> asList(T... a)
二、代码
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
asListDemo();
}
public static void arrayToStringDemo()
{
int[] arr={2,3,4};
System.out.println(Arrays.toString(arr));
}
public static void asListDemo()
{
String[] arr={"avc","abc","asdas"};
List<String> list=Arrays.asList(arr);
/*
把数组变成list集合，有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组编程集合，不可以使用集合的增删方法，
因为数组的长度是固定的。如果增删了，会报异常。
*/
int[] arr1={2,3,4};
List<int[]> list1=Arrays.asList(arr1);
/*
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
*/
System.out.println(list);
System.out.println(list1);
}
}
集合变数组(Collection to Array)
一、概述1.toArray方法
1.1返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
<T> T[] toArray(T[] a)
1.2返回包含此 collection 中所有元素的数组。
Object[] toArray()
二、代码
class ArraysDemo2 {public static void main(String[] args) {System.out.println("Hello World!");}public static void CollectionsToArray(){ArrayList<String> a1=new ArrayList<String>();a1.add("abc1");a1.add("abc2");a1.add("abc3");String[] arr=a1.toArray(new String[a1.size()])；//将数组设置为集合的大小，这样节省内存空间/*为什么要将集合变数组？为了限定对元素的操作，*/System.out.println(Arrays.toString(arr));//返回指定数组内容的字符串表示形式。}}
JDK1.5新特性——imoprt static
一、概述当类名重名时，需要制定具体的包名。当方法重名时，需要指定所属的对象或类名。
二、代码
import static java.util.Arrays.*;//导入的是————Arrays这个类中的所有静态成员。
import static java.lang.System.*;
class StaticImport
{
public static void main(String[] args)
{
int[] arr={3,4,5};
sort(arr);
//Arrays.sort(arr);
int index=binarySearch(arr,1);
//int index=Arrays.binarySearch(arr,1);
out.println(Arrays.toString(arr));//这个的Arrays不能省略，因为StaticImport继承了toString()
}
}
JDK1.5新特性——增强for循环
一、概述
格式：
for(数据类型 变量名 ：被遍历的集合(Collections)或者数组)
{
}
二、增强for和迭代器的区别
增强for循环:对集合进行遍历，只能获取元素，但是不能对集合进行操作
迭代器:除了遍历，还可以进行remove集合中元素的动作。
如果使用ListIterator，还可以在遍历过程中进行增删改查的动作。
建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义角标
四、注意事项 如果被迭代的集合没有指定泛型，那么使用增强for的时候，接收的数据类型只能是Object
五、代码
class enhanceFor
{
public static void main(String[] args)
{
ArrayList<String> a1=new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
for(String s :a1)
{
System.out.println(s);
}
}
}
JDK1.5新特性——可变参数
一、代码class ParamMethodDemo{public static void main(String[] args) {show(2);//会打印出一个数组的哈希值和数组类型show(1,2,3,4,5,6,7)/*可变参数其实就是数组参数(int[] arr={2,3,4,5};的简写形式。不用每一次都手动的建立对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。*/}public void show(String s,int... arr/*,String s 不可以放后面，只能可变参数放到最后面*/){System.out.println(arr);System.out.println(arr.length);//返回的是arr这个数组的长度}}