黑马程序员——Java基础--集合框架工具类:Collections、Arrays、其他对象

最新推荐文章于 2022-05-13 15:25:48 发布

huaiLxz

最新推荐文章于 2022-05-13 15:25:48 发布

阅读量784

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/huailxz/article/details/41441267

版权

Java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------

第一讲 Collections

一、简述

Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。

二、常见操作

查找：
- T max(Collection<? extends T> coll) 根据集合的自然顺序，获取coll集合中的最大元素。
- T max(Collection<? extends T> coll,Comparator<? super T> comp) 根据指定比较器comp的顺序，获取coll集合中的最大元素
- T min(Collection<? extends T> coll) 根据元素的自然顺序返回给定 collection 的最小元素。
- T min(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器产生的顺序，返回给定 collection 的最小元素。
- int intbinarySearch(Lsit<? extends Comparable<? super T>> list,Tkey) 二分法搜索list集合中的指定对象。
- int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 使用二分搜索法搜索指定列表，以获得指定对象。
- int indexOfSubList(List<?> source, List<?> target)
  - 返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
- int lastIndexOfSubList(List<?> source, List<?> target)
  - 返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
替换：
- void fill(List<? super T> list, T obj) 将list集合中的全部元素替换成指定对象obj。
- boolean replaceAll(List<T> lsit,T oldVal,T newVal) 用newVal替换集合中的oldVal值。
- void swap(Listlist,int i,int j) 在指定列表的指定位置处交换元素。
排序：
- void shuffle(List<?> list) 使用默认随机源对list集合中的元素进行随机排序。
- void sort(Lsit<T> list) 根据自然顺序对list集合中的元素进行排序。
- void sort(List<T> lsit,Comparator<? super T> c) 根据指定比较器c的排序方式对list集合进行排序。
反转：
- reverse(List<?> list) 反转list集合中元素的顺序
- Comparator reverseOrder() 返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序。
- ComparatorreverseOrder(Comparator<T> cmp) 返回一个比较器，强行逆转了指定比较器的顺序。
将非同步集合转成同步集合的方法：Collections中的 XXX synchronizedXXX(XXX);
- List<T>synchronizedList(List<T> list) 返回支持的同步（线程安全的）List集合。
- Map<K,V>synchronizedList(Map<K,V> m) 返回支持的同步（线程安全的）Map集合。

三、Collection和Collections的区别

Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

练习：

class  CollectionsDemo
{
	public static void main(String[] args) 
	{
		
	}
	//初始化
	public static void init()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
	}
	//折半查找
	public static void binarySearchDemo()
	{
		init();
		//按自然顺序查找
		//int index = Collections.binarySearch(list,"aaaa");
		//按比较器比较后的顺序查找
		int index = Collections.binarySearch(list,"aaaa",new StrLenComparator());
		sop("index="+index);
	}
	//获取最大值
	public static void maxDemo()
	{
		init()
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list/*,new StrLenComparator()*/);
		sop("max="+max);
	}
	//将集合按升序排序
	public static void sortDemo()
	{
		init();
		sop(list);

		//Collections.sort(list);
		Collections.sort(list,new StrLenComparator());
		//将指定位置元素互换
		//Collections.swap(list,1,2);
		sop(list);
		
	}
	//随机换位
	public static void shuffleDemo()
	{
		init();
		sop(list);
		Collections.shuffle(list);
		sop(list);
	}
	//集合反转,不传比较器按自然顺序反转，传比较器按比较器比较结果反转
	public static void orderDemo()
	{
		TreeSet<String> ts = new TreeSet<String>(/*Collections.reverseOrder(new StrLenComparator())*/);

		ts.add("abcde");
		ts.add("aaa");
		ts.add("k");
		ts.add("cc");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	//元素替换
	public static void replaceAllDemo()
	{
		init();
		sop(list);
		Collections.replaceAll(list,"aaa","pp");
		sop(list);
		Collections.reverse(list);
		sop(list);
	}

	//将list集合中部分元素替换成指定元素。
	public static void fillDemo()
	{
		init();
		sop(list);
		Collections.fill(list,"pp");
		sop(list);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
//定义比较器，让集合自身具备比较性。
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;
		*/
		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);
	}
}

第二讲 Arrays

一、简述

Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：isEmpty、 set、contains、get，indexOf，subList等方法。

二、常见方法

Lsit<T> asList(T... a) 将数组转换为集合。
binarySearch()：二分查找。
String toString() 可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。
注意：
- 数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；
- 如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
- 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
特点：
- 可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数。
- 可以对指定元素的范围，并可根据指定比较器进行相应的操作。
- sort(T[]a,Comparator<? super T> c) 排序。
- fill(int[]a,int from,int to) 替换。

练习：

import java.util.*;
class  ArraysDemo
{
	public static void main(String[] args) 
	{
		int[] numbs = {2,4,5};
		//将int型数组转换成指定数组的字符串表现形式
		sop(Arrays.toString(numbs));

		String[] arr = {"abc","cc","kkkk"};
		//将数组转换成集合
		List<String> list = Arrays.asList(arr);
		sop("contains:"+list.contains("cc"));
		//list.add("qq");//UnsupportedOperationException,
		//int[] nums = {2,4,5};
		Integer[] nums = {2,4,5};
		List<Integer> li = Arrays.asList(nums);

		/*
		如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
		如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
		*/
		sop(li);
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}

三、将集合转换成数组

方法：
- Collection接口中的方法： <T> T[] toArray(T[] a) 将集合变为指定类型的数组。
好处：
- 限定了对集合中的元素进行增删操作，只要获取这些元素即可。
指定类型的数组到底要定义多长呢？
- 如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。
- 如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。
- 所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

import java.util.*;
class  CollectionToArray
{
	public static void main(String[] args) 
	{
		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));
	}
}

第三讲扩展知识—JDK1.5部分新特性

简述

Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。

一、高级for循环

高级for循环：foreach语句，foreach简化了迭代器。
语法：
// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器
for( 元素类型变量名 : Collection集合 & 数组 ) {
…
}
高级for循环和传统for循环的区别：
- 高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
- 如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。
高级for循环可以遍历map集合吗？不可以，但是可以将map转成set后再使用foreach语句。
作用：对存储对象的容器进行迭代：数组 collection map
1. 增强for循环迭代数组：
  String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候
  for(String s : arr) {
  System.out.println(s);
  }
2. 单列集合 Collection：
  List list = new ArrayList();
  list.add("aaa");
  // 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能
  for(Object obj : list) {
  String s = (String) obj;
  System.out.println(s);
  }
3. 双列集合 Map：
  Map map = new HashMap();
  map.put("a", "aaa");
  // 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。
  for(Object obj : map.entrySet()) {
  Map.Entry entry = (Entry) obj; // obj 依次表示Entry
  System.out.println(entry.getKey() + "=" + entry.getValue());
  }
集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。
增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值。
int[] arr = {1,2,3};
for(int num : arr) {
num = 0; //不能改变数组的值
}
System.out.println(arr[1]); //2

二、可变参数

可变参数（...）：用到函数的参数上，当要操作的同一个类型元素个数不确定的时候。在传入时，每次都需要定义一个数组对象，作为实际参数。可是用这个方式，这个参数可以接受任意个数的同一类型的数据。

和接收数组不一样的是：
- 之前：定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。
- 现在：直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。
- 所以简化了用户的书写，少了调用者定义数组的动作。
如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败)。
如果要获取多个int数的和时，可以使用将多个int数封装到数组中，直接对数组求和即可。

class  ParamMethodDemo
{
	public static void main(String[] args) 
	{
		/*
		可变参数。
		其实就是上一种数组参数的简写形式。
		不用每一次都手动的建立数组对象。
		只要将要操作的元素作为参数传递即可。
		隐式将这些参数封装成了数组。
		*/
		show("zhangsan",1,3,5,5,9);
	}
	public static void show(String str,int... arr)
	{
		System.out.println(arr.length);
	}
}

三、静态导入

写法：
- import static java.util.Collections.*; //导入了Collections类中的所有静态成员
- import static java.util.Collections.sort; //导入了Collections类中的静态成员sort。
作用：
- 导入了类中的静态成员，简化静态成员的书写。
注意：
- 当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
- 当类名重名时，需要指定具体的包名。
- 当方法重名时，指定具体所属的对象或者类。

import static java.util.Collections.*;  
import static java.lang.System.*;  
class  CollectionsDemo3
{
	public static void main(String[] args) 
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		sort(list);//调用Collections类的sort方法
		out.println("max = " + max(list));//调用System类的out方法。
	}
}

第四讲其他类

一、System类

System是描述系统一些信息的类，类中的属性和方法都是静态的。不能被实例化，没有提供构造函数。
- out：标准输出流。默认是控制台。
- in：标准输入流。默认是键盘。

方法：
- Properties getProperties();获取系统的属性信息
  - 此方法返回的双列集合，即键值对；因为Properties是Hahstable的子类，也就是Map集合的一个子类对象，那么通过Map方法取出该集合中的元素。
  - 该集合存储的都是字符串，没有泛型定义。
- String getProperty(Stringkey);获取指定属性信息
- String setProperty(Stringkey,String value);在系统内定义特有信息
- 如何在jvm启动时，加载一些属性信息：通过命令：java -D<name>=<value>可以设置特有的系统属性信息

import java.util.*;  
class SystemDemo   
{  
	public static void main(String[] args)   
	{  
		Properties prop = System.getProperties();//获取当前的系统属性  
		System.out.println(prop);   
		  
		String value = System.getProperty("os.name");//获取指定键指示的系统属性  
		System.out.println("os.name=" + value);  
		  
		System.setProperty("wode","LXZ_PC");//设置指定键指示的系统属性信息  
		System.out.println(prop);  
				  
		String str = System.getProperty("lix");//当系统中没有该键值，返回null  
		System.out.println(str);  
		  
	}  
}

二、 Runtime类

特点
- 每个java应用程序都有一个Runtime类实例，使用应用程序能与其中运行的环境相连接，应用程序不能创建自己的Runtime类的实例，是由系统底层自己创建的。
- 该类中并没有提供构造函数。说明不可以new对象。
- 该类中有非静态方法。说明该类肯定会提供了方法获取本来对象。而且该方法是静态的，并返回值类型是本来类型。
- 由以上特点可以看出该类使用了单例设计模式完成。

方法：
- static RuntimegetRuntime();获取本类对象
- Processexec(String command);在单独的进程中执行指定字符串命令
- void destroy();在Process中有一个杀掉子进程的方法，可将exec方法开启的进程结束

class RuntimeDemo   
{  
    public static void main(String[] args)throws Exception  
    {  
        Runtime runing =Runtime.getRuntime();//获取本类对象  
  
        Process poce =r.exec("notepad.exe");//执行记事本程序  
        runing.exec("notepad.exe  RuntimeDemo.java");//用记事本打开指定文件  
  
        Thread.sleep(6000);//让线程等待6秒  
        poce.destroy();//杀掉指定进程  
    }  
}

三、时间类

1.Date类

Date类表示特定的瞬间，精确到毫秒。
Java中的默认显示格式为：Mon Nov 24 10:19:24 CST2014
自定义格式
- Java中默认的显示格式对于大多数人看着不习惯，我们可以根据自己的习惯来自定义时间格式。
- 因为Date类中的大部分方法已过时，所以只能找其子类来实现。子类DateFormat中有format方法可以实现，但是DateFormat是抽象类，不能实例化。
- 但是其下有个SimpleDateFormat子类，可以定义时间模式。
具体步骤：
1. 创建Date对象
2. 将时间模式封装到SimpleDateFormat对象中
3. 调用format方法让格式化模式指定Date对象

代码：

import java.util.*;  
import java.text.*;  
class DateDemo   
{  
    public static void main(String[] args)   
    {  
        Date d = new Date();//创建Date对象    
        //将模式封装到SimpleDateformat对象中。  
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E HH:mm:ss");  
        //调用format方法让模式格式化指定Date对象。  
        String time=sdf.format(d);  
        System.out.println(ojb)time);  
    }  
}

2.Carendar类

Calendar是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH等日历字段之间的转换提供了一些方法。
Calendar可以对年月日等时间进行获取。并提供了相应的子段值。

方法：
基本获取时间
- 获取年份：Calendar.YEAR
- 获取月份：Calendar.MONTH
- 获取日期：Calendar.DAY_OF_MONTH
- 获取星期：Calendar.DAY_OF_WEEK
- 获取小时：Calendar.HOUR_OF_DAY
- 获取分钟：Calendar.MINUTE
- 获取秒数：Calendar.SECOND
设置时间：
- 根据日历的规则，为给定的日历字段添加或减去指定的时间量： void add(int field,int amount);
- 获取指定的日历字段对应的时间值：int get(int field);
- 将给定日历字段对应的时间值设置为给定值：void set(int field,int value);
- 设置日历字段 YEAR、MONTH和DAY_OF_MONTH的值：void set(int year,int month,int date);

import java.util.*;
import java.text.*;

class  CalendarDemo
{
	public static void main(String[] args) 
	{

		Calendar c = Calendar.getInstance();

		String[] mons = {"一月","二月","三月","四月"
					,"五月","六月","七月","八月"
					,"九月","十月","十一月","十二月"};

		String[] weeks = {
						"","星期日","星期一","星期二","星期三","星期四","星期五","星期六",
							};		
		int index = c.get(Calendar.MONTH);

		int index1 = c.get(Calendar.DAY_OF_WEEK);

		sop(c.get(Calendar.YEAR)+"年");
		//sop((c.get(Calendar.MONTH)+1)+"月");
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
		sop(weeks[index1]);
	}

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

四、Math 类，Random类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
该类全为静态方法。
- doubleceil(double d); 返回大于指定数据的最小整数
- doublefloor(double d); 返回小于指定数据的最大整数
- double pow(doublea,double b); 返回a的b次方
- long round(doubleb); 返回b四舍五入的值
- doublerandom(); 返回正号的double值，是一个大于等于0.0且小于1.0的随机数
Random类
- java.util中的一个单独的类，该类对象用于获取随机数。
- 与Math中的random方法是一样的，不过这个类有自身的方法，可以将相应的随机数强转为指定基本数据类型。
- 如：intnextInt(int n);//返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。

import java.util.*;

class  MathDemo
{
	public static void main(String[] args) 
	{
		saveTwo(12.3456,3,true);//12.34
		show();
	}
	//给定一个小数。保留该小数的后两位。
	public static void saveTwo(double d,int scale,boolean isRound)
	{
		double base = Math.pow(10,scale);
		double num = isRound?Math.round(d*base)/base:((int)(d*base))/base;
		sop("num="+num);

	}

	public static void show()
	{
		double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
		double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。

		long l = Math.round(12.54);//四舍五入
		sop("d="+d);
		sop("d1="+d1);
		sop("l="+l);

		double d2 = Math.pow(2,3);
		sop("d2="+d2);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------