黑马程序员---Arrays工具类、高级for循环、静态导入

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

 

Arrays：用于操作数组的工具类。

里面都是静态方法。

 

Arrays中的静态方法，大致有如下几个部分：

二分查找指定类型的数组中的元素，前提该数组是有序的（升序）：

static int	binarySearch(byte[] a, byte key)           使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。
static int	binarySearch(byte[] a, int fromIndex, int toIndex, byte key)           使用二分搜索法来搜索指定的 byte 型数组的范围，以获得指定的值。
static int	binarySearch(char[] a, char key)           使用二分搜索法来搜索指定的 char 型数组，以获得指定的值。
static int	binarySearch(char[] a, int fromIndex, int toIndex, char key)           使用二分搜索法来搜索指定的 char 型数组的范围，以获得指定的值。
static int	binarySearch(double[] a, double key)           使用二分搜索法来搜索指定的 double 型数组，以获得指定的值。
static int	binarySearch(double[] a, int fromIndex, int toIndex, double key)           使用二分搜索法来搜索指定的 double 型数组的范围，以获得指定的值。
static int	binarySearch(float[] a, float key)           使用二分搜索法来搜索指定的 float 型数组，以获得指定的值。
static int	binarySearch(float[] a, int fromIndex, int toIndex, float key)           使用二分搜索法来搜索指定的 float 型数组的范围，以获得指定的值。
static int	binarySearch(int[] a, int key)           使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
static int	binarySearch(int[] a, int fromIndex, int toIndex, int key)           使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。
static int	binarySearch(long[] a, int fromIndex, int toIndex, long key)           使用二分搜索法来搜索指定的 long 型数组的范围，以获得指定的值。
static int	binarySearch(long[] a, long key)           使用二分搜索法来搜索指定的 long 型数组，以获得指定的值。
static int	binarySearch(Object[] a, int fromIndex, int toIndex,Object key)           使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static int	binarySearch(Object[] a,Object key)           使用二分搜索法来搜索指定数组，以获得指定对象。
static int	binarySearch(short[] a, int fromIndex, int toIndex, short key)           使用二分搜索法来搜索指定的 short 型数组的范围，以获得指定的值。
static int	binarySearch(short[] a, short key)           使用二分搜索法来搜索指定的 short 型数组，以获得指定的值。
static <T> int	binarySearch(T[] a, int fromIndex, int toIndex, T key,Comparator<? super T> c)           使用二分搜索法来搜索指定数组的范围，以获得指定对象。
static <T> int	binarySearch(T[] a, T key,Comparator<? super T> c)           使用二分搜索法来搜索指定数组，以获得指定对象。

 

复制数组从头开始的指定长度，返回到一个新数组中：

static boolean[]	copyOf(boolean[] original, int newLength)           复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。
static byte[]	copyOf(byte[] original, int newLength)           复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static char[]	copyOf(char[] original, int newLength)           复制指定的数组，截取或用 null 字符填充（如有必要），以使副本具有指定的长度。
static double[]	copyOf(double[] original, int newLength)           复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static float[]	copyOf(float[] original, int newLength)           复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static int[]	copyOf(int[] original, int newLength)           复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static long[]	copyOf(long[] original, int newLength)           复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static short[]	copyOf(short[] original, int newLength)           复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
static <T> T[]	copyOf(T[] original, int newLength)           复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。
static <T,U> T[]	copyOf(U[] original, int newLength,Class<? extends T[]> newType)           复制指定的数组，截取或用 null 填充（如有必要），以使副本具有指定的长度。

 

将指定数组的指定范围复制到一个新数组：

static boolean[]	copyOfRange(boolean[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static byte[]	copyOfRange(byte[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static char[]	copyOfRange(char[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static double[]	copyOfRange(double[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static float[]	copyOfRange(float[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static int[]	copyOfRange(int[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static long[]	copyOfRange(long[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static short[]	copyOfRange(short[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static <T> T[]	copyOfRange(T[] original, int from, int to)           将指定数组的指定范围复制到一个新数组。
static <T,U> T[]	copyOfRange(U[] original, int from, int to,Class<? extends T[]> newType)           将指定数组的指定范围复制到一个新数组。

 

比较的是两个数组中存放的内容是否相等：

static boolean	equals(boolean[] a, boolean[] a2)           如果两个指定的 boolean 型数组彼此相等，则返回 true。
static boolean	equals(byte[] a, byte[] a2)           如果两个指定的 byte 型数组彼此相等，则返回 true。
static boolean	equals(char[] a, char[] a2)           如果两个指定的 char 型数组彼此相等，则返回 true。
static boolean	equals(double[] a, double[] a2)           如果两个指定的 double 型数组彼此相等，则返回 true。
static boolean	equals(float[] a, float[] a2)           如果两个指定的 float 型数组彼此相等，则返回 true。
static boolean	equals(int[] a, int[] a2)           如果两个指定的 int 型数组彼此相等，则返回 true。
static boolean	equals(long[] a, long[] a2)           如果两个指定的 long 型数组彼此相等，则返回 true。
static boolean	equals(Object[] a,Object[] a2)           如果两个指定的 Objects 数组彼此相等，则返回 true。
static boolean	equals(short[] a, short[] a2)           如果两个指定的 short 型数组彼此相等，则返回 true。

 

深度比较，不光比较数组，还要比较数组里面元素的内容：

static boolean	deepEquals(Object[] a1,Object[] a2)           如果两个指定数组彼此是深层相等 的，则返回 true。
static int	deepHashCode(Object[] a)           基于指定数组的“深层内容”返回哈希码。
static String	deepToString(Object[] a)           返回指定数组“深层内容”的字符串表示形式。

 

使用指定的值，替换掉数组中的每一个（或指定范围的）元素：

static void	fill(boolean[] a, boolean val)           将指定的 boolean 值分配给指定 boolean 型数组的每个元素。
static void	fill(boolean[] a, int fromIndex, int toIndex, boolean val)           将指定的 boolean 值分配给指定 boolean 型数组指定范围中的每个元素。
static void	fill(byte[] a, byte val)           将指定的 byte 值分配给指定 byte 节型数组的每个元素。
static void	fill(byte[] a, int fromIndex, int toIndex, byte val)           将指定的 byte 值分配给指定 byte 型数组指定范围中的每个元素。
static void	fill(char[] a, char val)           将指定的 char 值分配给指定 char 型数组的每个元素。
static void	fill(char[] a, int fromIndex, int toIndex, char val)           将指定的 char 值分配给指定 char 型数组指定范围中的每个元素。
static void	fill(double[] a, double val)           将指定的 double 值分配给指定 double 型数组的每个元素。
static void	fill(double[] a, int fromIndex, int toIndex, double val)           将指定的 double 值分配给指定 double 型数组指定范围中的每个元素。
static void	fill(float[] a, float val)           将指定的 float 值分配给指定 float 型数组的每个元素。
static void	fill(float[] a, int fromIndex, int toIndex, float val)           将指定的 float 值分配给指定 float 型数组指定范围中的每个元素。
static void	fill(int[] a, int val)           将指定的 int 值分配给指定 int 型数组的每个元素。
static void	fill(int[] a, int fromIndex, int toIndex, int val)           将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
static void	fill(long[] a, int fromIndex, int toIndex, long val)           将指定的 long 值分配给指定 long 型数组指定范围中的每个元素。
static void	fill(long[] a, long val)           将指定的 long 值分配给指定 long 型数组的每个元素。
static void	fill(Object[] a, int fromIndex, int toIndex,Object val)           将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void	fill(Object[] a,Object val)           将指定的 Object 引用分配给指定 Object 数组的每个元素。
static void	fill(short[] a, int fromIndex, int toIndex, short val)           将指定的 short 值分配给指定 short 型数组指定范围中的每个元素。
static void	fill(short[] a, short val)           将指定的 short 值分配给指定 short 型数组的每个元素。

 

获取指定数组的哈希值：

static int	hashCode(boolean[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(byte[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(char[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(double[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(float[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(int[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(long[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(Object[] a)           基于指定数组的内容返回哈希码。
static int	hashCode(short[] a)           基于指定数组的内容返回哈希码。

 

对指定类型的数组整体或者局部进行排序：

static void	sort(byte[] a)           对指定的 byte 型数组按数字升序进行排序。
static void	sort(byte[] a, int fromIndex, int toIndex)           对指定 byte 型数组的指定范围按数字升序进行排序。
static void	sort(char[] a)           对指定的 char 型数组按数字升序进行排序。
static void	sort(char[] a, int fromIndex, int toIndex)           对指定 char 型数组的指定范围按数字升序进行排序。
static void	sort(double[] a)           对指定的 double 型数组按数字升序进行排序。
static void	sort(double[] a, int fromIndex, int toIndex)           对指定 double 型数组的指定范围按数字升序进行排序。
static void	sort(float[] a)           对指定的 float 型数组按数字升序进行排序。
static void	sort(float[] a, int fromIndex, int toIndex)           对指定 float 型数组的指定范围按数字升序进行排序。
static void	sort(int[] a)           对指定的 int 型数组按数字升序进行排序。
static void	sort(int[] a, int fromIndex, int toIndex)           对指定 int 型数组的指定范围按数字升序进行排序。
static void	sort(long[] a)           对指定的 long 型数组按数字升序进行排序。
static void	sort(long[] a, int fromIndex, int toIndex)           对指定 long 型数组的指定范围按数字升序进行排序。
static void	sort(Object[] a)           根据元素的自然顺序对指定对象数组按升序进行排序。
static void	sort(Object[] a, int fromIndex, int toIndex)           根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static void	sort(short[] a)           对指定的 short 型数组按数字升序进行排序。
static void	sort(short[] a, int fromIndex, int toIndex)           对指定 short 型数组的指定范围按数字升序进行排序。
static <T> void	sort(T[] a,Comparator<? super T> c)           根据指定比较器产生的顺序对指定对象数组进行排序。
static <T> void	sort(T[] a, int fromIndex, int toIndex,Comparator<? super T> c)           根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。

 

返回指定数组内容的字符串表示形式：(当年我们是用StringBuilder实现的)

static String	toString(boolean[] a)           返回指定数组内容的字符串表示形式。
static String	toString(byte[] a)           返回指定数组内容的字符串表示形式。
static String	toString(char[] a)           返回指定数组内容的字符串表示形式。
static String	toString(double[] a)           返回指定数组内容的字符串表示形式。
static String	toString(float[] a)           返回指定数组内容的字符串表示形式。
static String	toString(int[] a)           返回指定数组内容的字符串表示形式。
static String	toString(long[] a)           返回指定数组内容的字符串表示形式。
static String	toString(Object[] a)           返回指定数组内容的字符串表示形式。
static String	toString(short[] a)           返回指定数组内容的字符串表示形式。

 

演示：

import java.util.*;

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

	public static void printArray(char[] ch)
	{
		System.out.print("[ ");
		for(int x=0;x<ch.length;x++)
		{
			System.out.print(ch[x]+" ");
		}
		System.out.println("]");
	}

	public static void main(String[] args) 
	{
		char[] ch = {'a','b','c','d','e',};	
		char[] ch1 = {'a','b','c','d','e'};
		printArray(ch);

		char[] arr = Arrays.copyOf(ch,3);
		printArray(arr);
		
		char[] arr1 = Arrays.copyOfRange(ch,1,3);
		printArray(arr1);

		boolean b = Arrays.equals(ch,ch1);
		sop(b);

		String str = Arrays.toString(ch);
		sop(str);
	}
}

 

 

将数组变成List集合：

static <T> List<T>

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

把数组变成List集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

 

比如：我们要判断一个数组中是否包含某一个元素，我们就要写一个for循环遍历数组然后写判断方式。

把数组变成List集合以后，就可以通过List中的特有方法完成。

import java.util.*;
class ArraysDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

	public static void main(String[] args) 
	{
		String[] arr = {"abc","d","ef","hi","gk"};
		sop( Arrays.toString(arr) );

		List<String> list = Arrays.asList(arr);
		sop( list.contains("abc") );
	}
}

注意：将数组变成集合，不支持使用集合的增删方法，因为数组的长度是固定的。

其他方法可以使用：contains()，get()，indexOf()，subList()...

如果你增删了， 那么会发生：不支持操作异常UnsupportedOperationException。

 

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

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

演示：

import java.util.*;
class ArraysDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

	public static void main(String[] args) 
	{
		String[] arr = {"abc","d","ef","hi","gk"};
		sop( Arrays.toString(arr) );  // [abc, d, ef, hi, gk]

		List<String> list = Arrays.asList(arr);
		sop(list);  // [abc, d, ef, hi, gk]

		/*
		如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素，
		如果数组中的元素都是基本数据类型，那么就会将该数组作为集合中的元素存在。
		*/
		int[] in = {1,2,3,4,5};
		sop( Arrays.toString(in) );  // [1, 2, 3, 4, 5]

		List<int[]> li = Arrays.asList(in);
		sop(li);  // [[I@762589c3]

		/*如果这样写：*/
		Integer[] In = {1,2,3}; //这里自动装箱
		sop( Arrays.toString(In) ); // [1, 2, 3]

		List<Integer> lis = Arrays.asList(In);
		sop(lis); // [1, 2, 3]
	}
}

说完了数组变集合，再说说集合变数组：

这时我们想到一个问题，用谁的方法？

我们想起曾经学过的Collection接口中有个toArray()方法：

Object[]	toArray()           返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a)           返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

用 <T> T[] toArray(T[] a) 不需要类型强转：

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

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

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

   所以创建一个刚刚好的数组最优。

2.为什么要将集合变数组？

   为了限定对元素的操作。

   集合是可变长度的，你在操作的过程中进行增删增删，最后长度固定了，这时你不需要对方进行增删，你要转成数组返回给对方，因为数组的长度是固定的。

import java.util.*;
class CollectionToArray 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

	public static void main(String[] args) 
	{
		ArrayList<Integer> al = new ArrayList<Integer>();
		al.add(1);
		al.add(2);
		al.add(3);

		/*
		1.指定类型的数组到底要定义多长呢？

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

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

		所以创建一个刚刚好的数组最优。

		2.为什么要将集合变数组？

		为了限定对元素的操作。不需要进行增删了，

		*/
		Integer[] In = al.toArray(new Integer[al.size()]);
		sop( Arrays.toString(In) );
	}
}

 

ArrayList取出元素两种方式：1.迭代。  2.for循环，使用get(脚标)方法。 

Set取出元素只有一种方式：迭代器。

由于Enumeration枚举的书写太复杂，所以被Iterator迭代器取代了，我们说Iterator也经常写错，

1.5版本以后Collection 继承了接口 Iterable（可迭代的）

Map集合没有继承这个接口，说明Map里面没有迭代器，因为这个接口的出现其实就是将迭代方法抽取出来

这个接口有什么好处呢，它不光将迭代方法抽离出来，提高了集合框架的扩展性。

什么叫扩展性呢？等我们日后又出来一个Collection2，只要继承了这个接口，它里面就有了迭代方法。

把迭代方法提取出来以外，它还给集合框架提供了一个新功能，就是高级for循环------foreach循环。

 

高级for循环：

格式：

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

{

}

对集合进行遍历的时候：

这个高级for循环是有局限性的，它只能对集合中的元素进行取出，而不能做修改的动作。

Iterator至少还有一个remove()，

如果你使用的是ListIterator的话，增删改查功能都有。

 

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

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

比方说：将“hello world”这个字符串打印100遍。高级for是没有办法完成的。

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

 

重要：

import java.util.*;
class ForEachDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		//如果没加泛型，高级for循环里不能写String，只能写Object
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		//底层原理还是迭代器
		for(String s:al)//s第一次就指向了al中的第一个元素“abc1”,第二次...。s指向的对象在做着变化
		{
			s = "kk";//只是s的指向在做着变化
			//sop(s);
		}
		//sop(al);//[abc1, abc2, abc3]
		/*所以这个高级for循环是有局限性的，它只能对集合中的元素进行取出，而不能做修改的动作。
		迭代器Iterator至少还有一个remove()，
		如果你使用的是列表迭代器ListIterator的话，增删改查功能都有*/

		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(3,"aa");
		hm.put(5,"cc");
		hm.put(7,"bb");
		//问：我想把它里面的元素取出来，用高级for怎么做？

		Set<Integer> keySet = hm.keySet();
		for(Integer in : keySet)
		{
			sop(in+"::"+hm.get(in));
		}
		
		//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
		//for(Map.Entry<Integer,String> me : entrySet)
		for(Map.Entry<Integer,String> me : hm.entrySet())
		{
			sop(me.getKey()+"--"+me.getValue());
		}
	}
}

 

JDK1.5版本出现的新特性：可变参数

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

	public static void main(String[] args) 
	{
		/*
		show(1);
		show(1,2);
		show(1,2,3);

		虽然少定义了多个方法。
		但是每次都要定义一个数组。作为实际参数。
		int[] arr = {1,2,3};
		show(arr);
		int[] arr1 = {23,25,37,39,58};
		show(arr1);
		*/
	
		/*可变参数:
		其实就是上一种数组参数的简写形式，
		不用每一次都手动的建立数组对象，
		只要将要操作的元素作为参数传递即可，
		隐式的将这些参数封装成了数组。*/
		show(1,2,3);
		show(23,25,37,39,58);
	}

	/*
	public static void show(int a){}
	public static void show(int a,int b){}
	public static void show(int a,int b,int c){}

	public static void show(int[] arr){}
	*/

	public static void show(int... arr)
	{
		//sop(arr);//打印的是数组的地址:[I@51c2e8a4
		sop("length="+arr.length);
		sop(Arrays.toString(arr));
	}
}

 

方法的可变参数：

在使用时注意：可变参数一定要定义在参数列表最后面。

import java.util.*;
class ParamMethodDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

	public static void main(String[] args) 
	{
		show("hello",23,25,37,39,58);
	}

	public static void show(String s,int... arr)
	{
		System.out.print(s+",");
		sop(Arrays.toString(arr));
	}
}

 

1.5版本新特性：StaticImport静态导入

如果没有写static的话，导入的都是类。

如果import后面跟上static的话，导入的都是某一个类中的所有静态成员。

/*
StaticImport  静态导入。

当类名重名时，需要指定具体的包名。
当方法重名是，指定具备所属的对象或者类。

举例：
packa/Demo.class 
packb/Demo.class

import packa.*;
import packb.*;

new packa.Demo(); //不知道new哪个Demo，必须用指定的包名区分。
*/

import java.util.*; //如果没有写static的话，导的都是类。

import static java.util.Arrays.*; //导入的是Arrays这个类中的所有静态成员。

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

class StaticImport 
{
	public static void sop(Object obj)
	{
		out.println(obj);//省去System.
	}

	public static void main(String[] args) 
	{
		int[] arr = {3,1,5};

		sort(arr);//省了Arrays.
		int index = binarySearch(arr,3);//省了Arrays.
		sop(index);

		sop(Arrays.toString(arr));
		//此处不能省略Arrays.类名.。因为本类本身继承了Object，而Object里也有toString方法。
	}
}

 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net