Java基础 Collections Arrays 增强for循环 可变参数

Collections

java.util.Collections

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

示例代码

import java.util.*;

class CollectionsDemo
{
public static void main(String[] args)
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(2);
ilist.add(4);

//fillDemo(ilist,1,3,0);
//System.out.println(ilist);
replaceAllDemo();
}
public static void replaceAllDemo()
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(9);
ilist.add(4);
Collections.replaceAll(ilist,9,0);
System.out.println(ilist);
}
public static <T> void fillDemo(ArrayList<T> list,int start,int end,T t)
{
List<T> sublist=list.subList(start,end);

Collections.fill(sublist,t);
}
public static void binarySearceDemo()
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(2);
ilist.add(4);
MyComparator cmp=new MyComparator();

Collections.sort(ilist,cmp);
int index=Collections.binarySearch(ilist,5);
System.out.println(ilist+"index:"+index);
}
public static void maxDemo()
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(2);
ilist.add(4);
MyComparator cmp=new MyComparator();
System.out.println(Collections.max(ilist));
Collections.sort(ilist,cmp);
System.out.println(ilist);
}
}

class MyComparator implements Comparator<Integer>
{
public int compare(Integer i1,Integer i2)
{
int num=i1.compareTo(i2);
return num;

}
}

搜索 binarySearch

static <T> int  binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表，以获得指定对象。

逆转顺序

static void reverse(List<?> list)
反转指定列表中元素的顺序。
static <T> Comparator<T>  reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T>  reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。

元素位置交换swap

static void swap(List<?> list, int i, int j)
在指定列表的指定位置处交换元素。

获取线程安全的集合

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。

shuffle随机调整List元素位置

static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。

Arrays 用于操作数组的工具类

里面都是静态方法

asList:将数组变成List集合

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

可以用asList获取数组的List对象

不能对list进行 增，删，操作

可以使用其他操作。

contains()

get

set

indexOf

subList

因为数组长度是固定的。

public static <T> List<T> asList(T... a)

返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。
此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");

import java.util.*;

class ArraysDemo
{
public static void main(String[] args)
{
//String[] strArr={"abc","def","ghi"};
Integer[] intArr={1,2,3};

//List<String> list=Arrays.asList(strArr);
List<Integer> list=Arrays.asList(intArr);
//list.set(1);
System.out.println(list.get(0));
}

}

集合转成数组

toArray

import java.util.*;

class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> alist=new ArrayList<String>();

alist.add("abc1");
alist.add("abc2");
alist.add("abc3");

/*
1.指定类型的数组长度
指定类型的数组长度小于了集合的size，那么方法内部会创建一个
新的数组长度为集合的size
当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组
所以创建一个刚刚好的数组最优。
2.为什么要集合变数组
为了限定对元素的操作。
*/
String sArr[]=new String[alist.size()];

String[] arr=alist.toArray(sArr);
System.out.println(Arrays.toString(arr));
}
}

增强for 循环

对集合进行遍历。

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

迭代器除了遍历，还能remove集合中元素的动作。

如果使用ListIterator还可以在遍历过程中进行增删改查的动作。

传统for和高级for有什么区别呢?

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

建议在遍历数组的时候，使用传统for，因为传统for可以定义角标。

格式:

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

}

示例代码:

import java.util.*;

class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> alist=new ArrayList<String>();

alist.add("abc1");
alist.add("abc2");
alist.add("abc3");

for(String s:alist)
{
System.out.println(s);
}

/* Iterator<String> it=alist.iterator();

while(it.hasNext())
{
System.out.println(it.next());
} */

int[] arr={2,3,4};
for(int i : arr)
{
System.out.println("i:"+i);
}

HashMap<Integer,String> hm=new HashMap<Integer,String>();
hm.put(1,"abc1");
hm.put(2,"abc2");
for(Integer i : hm.keySet())
{
System.out.println("K:"+i+" V:"+hm.get(i));
}
//Set<Map.Entry<Integer,String>> entrySet=hm.entrySet();

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

可变参数

使用3个点

函数(类型… 变量名)

import java.util.*;
/*
JDK1.5版本出现的新特性
方法的可变参数
使用时注意：可变参数一定要定义在参数列表的最后面。
*/
class ParamMethodDemo
{
public static void main(String[] args)
{
//show(3,4);
/* int[] arr={3,4};
show(arr);
虽然少定义了多个方法,但是每次都要定义一个数组.作为实际参数.
int[] arr1={2,3,4,5}; */

/*
可变参数
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式的将这些参数封装成了数组。
*/
show(2,3,2,2);
show2("test",2,3,4);
}
public static void show2(String s,int... arr)
{
System.out.println(s);
for(int i : arr)
System.out.println(i);
}
public static void show(int... arr)//第三种方法,可变参数
{
//自动封装int型数组arr
for(int i : arr)
System.out.println(i);
}
/* public static void show(int[] arr)//第二种方法传递数组
{

}
public static void show(int a,int b)//第一种方法,写多个重载函数
{
System.out.println(a+","+b);
} */
}

静态导入 StaticImport

import java.util.*;
/*
JDK1.5版本出现的新特性
当类名重名时，需要指定具体的包名
当方法重名时，需要指定具体所属的对象或者类。
*/
import static java.util.Arrays.*;//导入Arrays这个类中的静态成员.
import static java.lang.System.*;
class StaticImport extends Object
{
public static void main(String[] args)
{
out.println("test");
int[] arr={3,1,5};

sort(arr);
int index = binarySearch(arr,1);
System.out.println("Index="+index);
System.out.println(Arrays.toString(arr));//toString方法重名
}
}