集合操作类Collections和Arrays，JDK1.5新特性

1----------------------------------------------------------------

/*
java.util.包

1.Collections  这个类是Collection的一个操作类

2.Arrays       这个类是数组的操作类,，这两个类中所有的方法都是static

Collections下常用方法

1.sort
1.1 public static void sort(List list)
作用：对List集合中的元素按照元素的自然顺序排序。
1.2 public static void sort(List list,Comparator c);
作用：对List集合中的元素按照指定的比较器c进行排序.
2.max  min
2.1 max
2.1.1
public static T max(Collection<? extends T> c)
得到Collection中的元素的最大值(按元素的自然顺序)
2.1.2 
public static T max(Collection c,Comparator)
得到collection中的元素的最大值(按指定的比较器)
2.2 min
2.2.1
public static T min(Collection<? extends T> c)
得到Collection中的元素的最小值(按元素的自然顺序)
2.2.2 
public static T min(Collection c,Comparator)
得到collection中的元素的最小值(按指定的比较器)
3. reverse
定义 public static void reverse(List list);
作用 集合中的元素反转
4. shuffle
定义  public static void shuffle(List list);
作用  集合中的元素乱序
5. swap
定义  public static void swap(List list,int i,int j)
作用  将list集合中的i,j位置上的元素交换。
6. binarySearch
6.1  public static int binarySearch(List list, T key)
作用 使用二分法查找，key在list集合中的索引位置 元素的比较是使用元素的自然顺序。
    如果存在，返回这个索引，如果不存在，返回(-(插入点)-1)
插入点就是key这个元素如果存入list集合中的位置。
6.2  public static int binarySearch(List list,T key,Comparator c)

作用 使用二分法查找，key在list集合中的索引位置 元素的比较使用的是c这个比较器
    如果存在，返回这个索引，如果不存在，返回(-(插入点)-1)
插入点就是key这个元素如果存入list集合中的位置。
7. reverseOrder
7.1 public static Comparator reverseOrder()  得到集合元素的自然顺序的反序
7.2 public static Comparator reverseOrder(Comparator c)得到c这个比较器的反的比较器

*/

import java.util.*;
class Demo2
{
public static void main(String[] args)
{
new CollectionsDemo().method6();
}

}

class CollectionsDemo
{
//sort
public void method1(){
/*
//使用sort按照自然顺序排序
List<String> list=new ArrayList<String>();
list.add("abc");
list.add("aaa");
list.add("sdf");
list.add("rwds");

Collections.sort(list);

System.out.println(list);
*/
List<Student> list=new ArrayList<Student>();
list.add(new Student(20));
list.add(new Student(21));
list.add(new Student(19));
Collections.sort(list,
new Comparator<Student>(){
public int compare(Student s1,Student s2){

return s1.age-s2.age;
}
}
);
System.out.println(list);

}

//max
public void method2(){
/*
//按照集合中的元素的自然顺序得到最大值
List<String> list=new ArrayList<String>();
list.add("abc");
list.add("aaa");
list.add("sdf");
list.add("rwds");

String max=Collections.max(list);

System.out.println(max);
*/
List<Student> list=new ArrayList<Student>();
list.add(new Student(20));
list.add(new Student(21));
list.add(new Student(19));

Student max=Collections.max(list,new Comparator<Student>(){
public int compare(Student s1,Student s2){

return s1.age-s2.age;
}
});

System.out.println(max);

}

//reverse  反转
//shuffle  乱序
//swap      指定位置元素置换
public void method3(){

List<String> list=new ArrayList<String>();
list.add("abc");
list.add("aaa");
list.add("sdf");
list.add("rwds");

System.out.println(list);

Collections.swap(list,1,2);

System.out.println(list);
//Collections.sort(list);//升序
//想要降序
//Collections.reverse(list);//将集合中的元素反转。
//System.out.println(list);
//Collections.shuffle(list);
//System.out.println(list);
}

public void method4(){
/*
List<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(6);

//二分法查找
int index=Collections.binarySearch(list,5);

System.out.println(index);
*/
List<Student> list=new ArrayList<Student>();
list.add(new Student(19));
list.add(new Student(20));
list.add(new Student(21));

int index=Collections.binarySearch(list,new Student(190),
new Comparator<Student>(){
public int compare(Student s1,Student s2){

return s1.age-s2.age;
}
}
);

System.out.println(index);

}
//reverseOrder(Comparator c)
public void method5(){

//比较器对象
Comparator<String> c=new Comparator<String>(){

public int compare(String s1,String s2){
return s1.length()-s2.length();
}
};
TreeSet<String> set=new TreeSet<String>(c);

set.add("asdf");
set.add("dsdfe");
set.add("dsadfas");
set.add("fisudjsd");

//要按照元素的长度进行排序
System.out.println(set);  //set这个集合的比较器是按照元素的长度进行排序

//得到比较器
Comparator<String> rc=Collections.reverseOrder(c); //得到c这个比较器的反转的操作

List<String> list=new ArrayList<String>();
list.add("dsadfas");
list.add("fisudjsd");
list.add("asdf");
list.add("dsdfe");

Collections.sort(list,rc);

System.out.println(list);

}

//无参
public void method6(){

List<Student> list=new ArrayList<Student>();
list.add(new Student(20));
list.add(new Student(21));
list.add(new Student(19));

Collections.sort(list);//自然顺序，是按照年龄从小到大
System.out.println(list);
Collections.sort(list,Collections.reverseOrder()); //将自然顺序逆序,简单说就是按照年龄从大到小.

System.out.println(list);

}

}

class Student implements Comparable<Student>
{
int age;
public Student(int age){
this.age=age;
}

public String toString(){

return "年龄:"+age;
}

public int compareTo(Student s){

return age-s.age;
}
}

/*
Arrays 是数组的操作类

1.fill  作用是将数组中的元素填充成指定的值。

2.copyOf  作用是复制数组，可以复制数组中的一部分。

3.sort  作用是对数组中的元素进行排序

4.toString

5. asList  
作用是将一个数组转换成集合
为什么这么做，因为集合中的操作方法更丰富。那我们就可以使用集合中的方法。

数组转换成集合后，不能使用集合的添加与删除操作，也就是说不能更改长度.

注意：
如果asList操作时 参数是一个数组，

如果数组中元素是引用类型,将这个数组中的所有元素直接放入到集合中
如果数组中元素是基本类型，那么是将这个数组做为元素放入到集合中。

*/

import java.util.*;
class Demo4
{
public static void main(String[] args)
{
method();
}
//asList注意
public static void method(){

int[] arr={1,2,3};

List<int[]> list=Arrays.asList(arr); //发现集合中存储的不是Integer对象，是int[]类型

for(int i=0;i<list.size();i++){

int[] arr1=list.get(i);

for(int j=0;j<arr1.length;j++){

System.out.println(arr1[j]);
}
}
}

//asList
public static void method0(){

String[] s=new String[]{"a","b","c"};

//将数组转换成List

List<String> list=Arrays.asList(s);
//对于这些添加与删除的方法不支持.简单说不能更改长度，因为数组是定长的。

list.add("d"); //java.lang.UnsupportedOperationException

System.out.println(list);
}

public static void method1(){

String[] s=new String[10];

Arrays.fill(s,"abc");

for(int i=0;i<s.length;i++){

System.out.println(s[i]);
}
}

public static void method2(){

String[] s=new String[]{"a","b","c"};

//Arrays.fill(s,"abc");

String[] st=Arrays.copyOf(s,2);

for(int i=0;i<st.length;i++){

System.out.println(st[i]);
}
}

public static void method3(){

int[] arr={1,2,3,4,5,6};

System.out.println(Arrays.toString(arr));
}
}

集合体系  jdk1.2出现的集合类基本都是不同步

public static List synchronizedList(List list);

作用  将一个非同步的list集合变成同步的List

注意一下起名的规范

Xxx synchronizedXxx(Xxx x)

Xxx 可以代表  Collection  List  Set  Map

它们的作用都是将不同步的集合变成同步的。

class Demo3
{
public static void main(String[] args)
{
List list=new ArrayList(); //这个是不同步的

List slist=Collections.synchronizedList(list);//同步的。

}
}

package cn.baidu.com;

import java.util.*;
/*
* 集合框架的工具类
*/

public class CollectionsDemo {

public static void main(String[] args) {
binarySearchDemo();
}
public static void binarySearchDemo()
{
List<String> list =new ArrayList<String>();
list.add("aafasdfsdfsa");
list.add("bbdfa");
list.add("acdd");
list.add("sddfaxdd");
sop(list);
Collections.sort(list);

int index=Collections.binarySearch(list,"acdd");
sop("binarySearch查找的index="+index);

int index1=halfSerach2(list,"acdd",new StrLenComparator());
sop("我的二分法查找到的index为："+index);
}
public static void sortDemo()
{
List<String> list =new ArrayList<String>();
list.add("aafasdfsdfsa");
list.add("bbdfa");
list.add("acdd");
list.add("sddfaxdd");
sop(list);

Collections.sort(list);
sop(list);
Collections.sort(list,new StrLenComparator());
sop(list);

}
public static void maxDemo()
{
List<String> list =new ArrayList<String>();
list.add("aafasdfsdfsa");
list.add("bbdfa");
list.add("acdd");
list.add("sddfaxdd");
sop(list);

String max=Collections.max(list);
sop("max="+max);
String max1=Collections.max(list,new StrLenComparator());
sop("maxlen="+max1);
}

public static void sop(Object obj)
{
System.out.println(obj);
}

public static int halfSerach(List<String> list,String key)
{
int max,min,mid;
max=list.size()-1;
min=0;

while(min<=max)
{
mid=(max+min)>>1;
String str=list.get(mid);//根据索引查找中间数
int num=str.compareTo(key);
if(num>0)
max=mid-1;
else if(num<0)
min=mid+1;
else
return mid;
}
return -min-1;//返回-index-1
}
//对象可能没有比较性，需要构造一个比较器
public static int halfSerach2(List<String> list,String key,Comparator<String> cmp)
{
int max,min,mid;
max=list.size();
min=0;
mid=(max+min)>>1;
while(min<=max)
{
String str=list.get(mid);//根据索引查找中间数
int num=cmp.compare(str, key);
if(num>0)
max=mid-1;
else if(num<0)
min=mid+1;
else
return mid;
}
return -min-1;//返回-index-1
}
}
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);

}
}

2--------------------------------------------------------------------------------------

//数组变集合
import java.util.*;
public class ArraysDemo {

public static void main(String[] args) {
//int[] arr={2,3,4};
//System.out.println(Arrays.toString(arr));

String[] arr={"dsf","err","wer"};
//把数组变成list集合有什么好处
/*
* 可以使用集合的思想和方法来操作数组中的元素。
* 注意：将数组变成集合，不可以使用集合的增删方法，会产生UnsupportedOperationException,
* 因为数组的长度是固定的
*/
List<String> list=Arrays.asList(arr);
sop(list);
sop("contains="+list.contains("dsf"));
sop(list);

int[] num1={4,5,5,3,2};
List<int[]> li1=Arrays.asList(num1);
sop(li1);

Integer[] nums={4,5,5,3,2};

List<Integer> li=Arrays.asList(nums);
sop(li);

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

}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static boolean myContains(String[] arr,String key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x].equals(key))
return true;
}
return false;
}

}

3.-----------------------------------------------------------------------------------------------

Collections-reverseOrder

import java.util.*;
class StrComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num=s1.compareTo(s2);
if(num>0)
return -1;
if(num<0)
return 1;
return num;
}
}
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);
}
}
class  CollectionsDemo
{
public static void main(String[] args)
{
orderDemo();
}
public static void orderDemo()
{
//TreeSet<String> ts=new TreeSet<String>(new StrComparator());

//TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder());//反转
TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));//逆转一个比较器
ts.add("sdfsdf");
ts.add("bdf");
ts.add("adfsf");
ts.add("wdff");

Iterator<String> it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}

}
}

4.-----------------------------------------------------------------------------------

/*
集合变数组
Collection 接口   toArray();

<T> T[] toArray(T[] t);
*/
import java.util.*;
class Demo5
{
public static void main(String[] args)
{
List<String> list=new ArrayList<String>();

list.add("a");
list.add("b");
list.add("c");

String[] st=list.toArray(new String[list.size]); //相当于告诉集合应该装入什么样的数组中。
/*
参数作用：是声明一个数组，将集合中的元素都装入到数组中，
如果数组长度小于集合长度,得到的数组长度与集合的长度一样。
如果数组长度大于集合长度,得到的数组是我们声明的数组的长度，无元素填充的位置用null。

在开发使用时，我们一般指定都直接使用集合的长度

这种操作的作用是什么？
数组的长度是定长的，为了不更改集合的长度。

*/

for(int i=0;i<st.length;i++){

System.out.println(st[i]);
}

}
}

import java.util.*;
public class CollectionToArray {

public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> al=new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");

String[] arr=al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}

}

5.-------------------------------------------------------------------------

/*jdk1.5 新特性

 * 高级for循环

 * 格式：

 * for(数据类型 变量名：被遍历的集合(Collection)或者数组)

 * {

 * }

 * 对集合进行遍历

 * 只能获取集合元素，但是不能对集合进行操作

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

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

 * 

 * 传统for循环和高级for的区别

 * 高级for有一个局限性，必须有被遍历的目标

 * 建议在遍历数组的时候还是使用传统for

import java.util.*;
public class ForEachDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> al=new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");

for(String s:al)
{
s="kk";
System.out.println(s);
}

Iterator<String> it=al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
HashMap<Integer,String> hm=new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");

Set<Integer> keyset=hm.keySet();
for(Integer i:keyset)
{
System.out.println(i+"::"+hm.get(i));
}

Set<Map.Entry<Integer, String>> entrySet=hm.entrySet();
for(Map.Entry<Integer, String> me:entrySet)
{

}

for(Map.Entry<Integer, String> me:hm.entrySet())
{
System.out.println(me.getKey()+"-----"+me.getValue());
}

}

}

import java.util.*;
class Demo6
{
public static void main(String[] args)
{

//List<String> list=new ArrayList<String>();

//list.add("a");
//list.add("b");
//list.add("c");
//list.add("d");

//第一种方式 List集合特有
/*
for(int i=0;i<list.size();i++){

System.out.println(list.get(i));
}
//ListIterator还可以使用
*/

//第二种方式  iterator  Collection所有集合通用
/*
for(Iterator<String> it=list.iterator();it.hasNext();){
System.out.println(it.next());
}*/

//增强for
/*
for(String s:list){

System.out.println(s);
}*/

/*
//增强for操作数组

String[] st={"a","b","c"};

for(String s:st){

System.out.println(s);
}*/

//for不能直接操作Map，还是需要间接操作
//Map<Integer,String> map=new HashMap<Integer,String>();

//map.put(1,"a");
//map.put(11,"b");
//map.put(111,"c");
/*
Set<Integer> set=map.keySet();
//增强for可以直接迭代Set
for(int key:set){

System.out.println("KEY:"+key+"  VALUE:"+map.get(key));

}*/
/*
Set<Map.Entry<Integer,String>> set=map.entrySet();

for(Map.Entry<Integer,String> me:set){

System.out.println("KEY:"+me.getKey()+"  VALUE:"+me.getValue());

}*/

//增强for遍历二维数组

int[][] arr={{1,2,3},{4,5,6},{7,8,9}};

for(int[] a:arr){

for(int n:a){
System.out.print(n+"  ");
}
System.out.println();
}

}
}

jdk1.5 新特性

静态导入

简化写法

在应用时，如果方法名重复，那么通过参数是可以区分，
如果区分不开，那么这时必须指定是哪个类中的方法。

import java.util.*;
import static java.util.Collections.*; //导入Collections所有static方法
import static java.util.Arrays.*;
class Demo7
{
public static void main(String[] args)
{
List<Integer> list=new ArrayList<Integer>();
list.add(22);
list.add(12);
list.add(32);

sort(list);//它是Collections中的sort

System.out.println(list);
int[] arr={24,22,53};

sort(arr);

//System.out.println(toString(arr)); //认为与Object类中继承的toString方法相同

System.out.println(Arrays.toString(arr));
}

//public static void sort(List list){
//	System.out.println("本类的sort方法");
//}
}

jdk1.5 新特性

动态参数

动态参数写法   类型...

动态参数注意：动态参数后面不要在写其它参数，如果有的话，写在动态参数前面。

import java.util.*;
class Demo8
{
public static void main(String[] args)
{
Demo8 d=new Demo8();
d.add(1,2);  //相当于将1,2都传递到a数组中
d.add(1,2,3,4,5);

d.method();
}
public void add(int b,int... a){ //对于这个程序来说 a相当于是一个数组

System.out.println(a.length);
}

//List<T> asList(T... a)
public void method(){

List<Integer> list=Arrays.asList(1,2,3,4,5);

System.out.println(list);
}
/*
//求a与b的和
public void add(int a,int b){
System.out.println(a+b);
}
//求a,b,c的和
public void add(int a,int b,int c){

System.out.println(a+b+c);
}
// 如果我们求多个数的和，应用想到应用数组.
public void add(int[] arr){

}
*/

}