JavaSe基础XX17——常用对象API-集合框架_5_ 工具类

最新推荐文章于 2024-01-16 14:33:56 发布

lovewaterman

最新推荐文章于 2024-01-16 14:33:56 发布

阅读量565

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/lovewaterman/article/details/38979521

版权

JavaSE 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

utilities

|--Collections

|--Arrays

*13-常用对象API(集合框架-工具类-Collections-排序)

允许重复、按某个规则顺序输出。

Collections——工具类

Collection——接口

// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);

*14-常用对象API(集合框架-工具类-Collections-折半&最值)

*16-常用对象API(集合框架-工具类-Collections-其他方法&将非同步集合转成同步集合的方法)

自己实现：

封装：

其他：

replaceall(List,T old,T new)

怎么实现的呢？

*16-常用对象API(集合框架-工具类-Collections-其他方法&将非同步集合转成同步集合的方法)

枚举----ArrayListm 相互转换、

ArrayList：多线程，如何加锁同步。

List list = new ArrayList();//非同步的。

list = MyCollections.synList(list);//返回一个同步的list.







给非同步的集合加锁。

class MyCollections{

	public static  List synList(List list){
		
		return new MyList(list);
	}

	private class MyList implements List{
	private List list;
	
	private static final Object lock = new Object();
	MyList(List list){	
		this.list = list;	
	}
	
	public boolean add(Object obj){
		synchronized(lock)
		{
			return list.add(obj);
		}
	}
	
	public boolean remove(Object obj){
		synchronized(lock)
		{
			return list.remove(obj);
		}
	}

}
}

-----------------------小结-------------------------

package cn.itcast.p2.toolclass.collections.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;

import cn.itcast.p2.comparator.ComparatorByLength;

public class CollectionsDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		/*
		 * Collections：是集合框架的工具类。
		 * 里面的方法都是静态的。
		 * 
		 * 
		 */
		
		demo_4();
	}
	
	public static void demo_4() {
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("zhangsan");
		list.add("zhaoliu");
		list.add("xiaoqiang");
		
		System.out.println(list);
//		Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");
		Collections.shuffle(list);
//		Collections.fill(list, "cc");
		System.out.println(list);
	}

	public static void demo_3() {
		/*
		TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){

			@Override
			public int compare(String o1, String o2) {
				
				int temp = o2.compareTo(o1);
				return temp;
			}
			
		});
		*/
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));	
		
		ts.add("abc");
		ts.add("hahaha");
		ts.add("zzz");
		ts.add("aa");
		ts.add("cba");
		
		System.out.println(ts);
		
	}

	public static void demo_2(){
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");
//		Collections.sort(list);
		System.out.println(list);
		
//		int index = Collections.binarySearch(list, "cba");		
//		System.out.println("index="+index);
		
		//获取最大值。
		String max = Collections.max(list,new ComparatorByLength());
		System.out.println("max="+max);
	}
	
	
	
	public static void demo_1(){
		
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");
		System.out.println(list);
		
		
		//对list集合进行指定顺序的排序。
//		Collections.sort(list);
//		mySort(list);
//		mySort(list,new ComparatorByLength());
		Collections.sort(list,new ComparatorByLength());
		System.out.println(list);
	}
	public static <T> void mySort(List<T> list,Comparator<? super T> comp){
		
		for (int i = 0; i < list.size()-1; i++) {
			
			for (int j = i+1; j < list.size(); j++) {
				
				if(comp.compare(list.get(i), list.get(j))>0){
					
//					T temp = list.get(i);
//					list.set(i, list.get(j));
//					list.set(j, temp);
					Collections.swap(list, i, j);
					
				}
			}
		}
	}
	
	
	public static <T extends Comparable<? super T>> void mySort(List<T> list){
		
		for (int i = 0; i < list.size()-1; i++) {
			
			for (int j = i+1; j < list.size(); j++) {
				
				if(list.get(i).compareTo(list.get(j))>0){
					
//					T temp = list.get(i);
//					list.set(i, list.get(j));
//					list.set(j, temp);
					Collections.swap(list, i, j);
					
				}
			}
		}
	}

}

*17-常用对象API(集合框架-工具类-Arrays-方法介绍)

	//toString的经典实现。
	public static String myToString(int[] a){
		int iMax = a.length - 1;
		if (iMax == -1)
	            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0;  ; i++) {//中间省略条件判断，提高了效率。
            b.append(a[i]);
	    if (i == iMax)
	    	return b.append(']').toString();
           b.append(", ");
        }
	}

*18-常用对象API(集合框架-工具类-Arrays-asList方法)

数组转集合。为什么？集合的方法多！

为什么只有一个元素呢？

-------------------------小结-------------------------

package cn.itcast.p3.toolclass.arrays.demo;

import java.util.Arrays;
import java.util.List;


//数组转成集合。
public class ArraysDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*
		 * Arrays：集合框架的工具类。里面的方法都是静态的。
		 * 
		 */
		
//		int[] arr = {3,1,5,6,3,6};		
//		System.out.println(Arrays.toString(arr));
		
		demo_2();
	}

	public static void demo_2() {
		
		/*
		 * 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
		 * 
		 * 如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。
		 * 
		 */
		int[] arr = {31,11,51,61};
		
		List<int[]> list = Arrays.asList(arr);
		
		System.out.println(list);
	}

	/**
	 * 
	 */
	public static void demo_1() {
		/*
		 * 重点：List asList(数组)将数组转成集合。
		 * 
		 * 好处：其实可以使用集合的方法操作数组中的元素。
		 * 注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的
		 * 否则会发生UnsupportedOperationException
		 * 
		 * 
		 */
		String[] arr = {"abc","haha","xixi"};
		
		boolean b = myContains(arr, "xixi");
		System.out.println("contains:"+b);
		
		List<String> list = Arrays.asList(arr);
		boolean b1 = list.contains("xixi");
		System.out.println("list contaisn:="+b1);
//		list.add("hiahia");//UnsupportedOperationException
		
		System.out.println(list);
	}
	
	public static boolean myContains(String[] arr,String key){
		for (int i = 0; i < arr.length; i++) {
			if(arr[i].equals(key))
				return true;
		}
		return false;
	}
	
	//toString的经典实现。
	public static String myToString(int[] a){
		int iMax = a.length - 1;
		if (iMax == -1)
	            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0;  ; i++) {//中间省略条件判断，提高了效率。
            b.append(a[i]);
	    if (i == iMax)
	    	return b.append(']').toString();
           b.append(", ");
        }
	}

}

*19-常用对象API(集合框架-工具类-Collection-toArray方法)

集合转数组，

集合为什么变数组——可以对集合中的元素，操作的方法进行限定。不允许对其进行增删。

package cn.itcast.p3.toolclass.arrays.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ToArray {
	public static void main(String[] args) {
		
		
		/*
		 * 集合转成数组呢？
		 * 
		 * 使用的就是Collection接口中的toArray方法。
		 * 
		 * 集合转成数组：可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
		 * 
		 * 
		 */
		
		List<String> list = new ArrayList<String>();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		
		
		/*
		 * toArray方法需要传入一个指定类型的数组。
		 * 长度该如何定义呢？
		 * 如果长度小于集合的size，那么该方法会创建一个同类型并和集合相同size的数组。
		 * 如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为null。
		 * 
		 * 所以建议，最后长度就指定为，集合的size。
		 */
		String[] arr = list.toArray(new String[list.size()]);
		
		System.out.println(Arrays.toString(arr));
		
		
	}
}

*20-常用对象API(集合框架-JDK5.0特性-ForEach循环)

/*
* foreach语句：
* 格式：
* for(类型变量：Collection集合|数组)
* {
*
* }
*
* 传统for和高级for的区别？
* 传统for可以完成对语句执行很多次，因为可以定义控制循环的增量和条件。
*
* 高级for是一种简化形式。
* 它必须有被遍历的目标。该目标要是数组，要么是Collection单列集合。
*
* 对数数组的遍历如果仅仅是获取数组中的元素，可以使用高级for。
* 如果要对数组的角标进行操作建议使用传统for。
*
*/

只用于遍历

package cn.itcast.p4.news.demo;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;




public class ForEachDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		/*
		 * foreach语句：
		 * 格式：
		 * for(类型  变量   ：Collection集合|数组)
		 * {
		 * 		
		 * }
		 * 
		 * 传统for和高级for的区别？
		 * 传统for可以完成对语句执行很多次，因为可以定义控制循环的增量和条件。
		 * 
		 * 高级for是一种简化形式。
		 * 它必须有被遍历的目标。该目标要是数组，要么是Collection单列集合。
		 * 
		 * 对数数组的遍历如果仅仅是获取数组中的元素，可以使用高级for。
		 * 如果要对数组的角标进行操作建议使用传统for。 
		 *  
		 */
		
		List<String> list =new ArrayList<String>();
		
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		
		for(String s : list){	//简化书写。		
			System.out.println(s);			
		}
		
		
		int[] arr = {3,1,5,7,4};
		
		for(int i : arr){
			System.out.println(i);
		}
		
		
		//可以使用高级for遍历map集合吗？不能直接用，但是可以将map转成单列的set，就可以用了。
		Map<Integer,String> map = new HashMap<Integer,String>();
		
		map.put(3,"zhagsan");
		map.put(1,"wangyi");
		map.put(7,"wagnwu");
		map.put(4,"zhagsansan");
		
		
		for(Integer key : map.keySet()){
			String value = map.get(key);
			System.out.println(key+"::"+value);
		}
		
		for(Map.Entry<Integer,String> me : map.entrySet()){
			Integer key = me.getKey();
			String value = me.getValue();
			
			System.out.println(key+":"+value);
		}
		
		
//		Iterator<String> it = list.iterator();	
//		while(it.hasNext()){
//			System.out.println(it.next());
//		}
		
		
	}

}

*21-常用对象API(集合框架-JDK5.0特性-函数可变参数)

可变参数：创建数组、传递参数，自动将这些数字转化为数组。

局限性：

package cn.itcast.p4.news.demo;

public class ParamterDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

//		int sum = add(4,5);
//		System.out.println("sum="+sum);
//		int sum1 = add(4,5,6);
//		System.out.println("sum1="+sum1);
		
		
//		int[] arr = {5,1,4,7,3};
//		int sum = add(arr);
//		System.out.println("sum="+sum);
//		int[] arr1 = {5,1,4,7,3,9,8,7,6};
//		int sum1 = add(arr1);
//		System.out.println("sum1="+sum1);
		
		int sum = newAdd(5,1,4,7,3);
		System.out.println("sum="+sum);
		int sum1 = newAdd(5,1,2,7,3,9,8,7,6);
		System.out.println("sum1="+sum1);
		
	}
	/*
	 * 函数的可变参数。
	 * 其实就是一个数组，但是接收的是数组的元素。
	 * 自动将这些元素封装成数组。简化了调用者的书写。
	 * 
	 * 注意：可变参数类型，必须定义在参数列表的结尾。
	 * 
	 */
	public static int newAdd(int a,int...  arr){
		
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum+=arr[i];
		}
		return sum;
		
//		System.out.println(arr);		
//		return 0;
	}
	
	public static int add(int[] arr){
		
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum+=arr[i];
		}
		return sum;
		
	}
	
	
	
	public static int add(int a,int b){
		return a+b;
	}
	
	public static int add(int a,int b,int c){
		return a+b+c;
	}

}

*22-常用对象API(集合框架-JDK5.0特性-静态导入)

package cn.itcast.p4.news.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.*;//静态导入，其实到入的是类中的静态成员。
//import static java.util.Collections.max;//静态导入，其实到入的是类中的静态成员。

import static java.lang.System.*;

public class StaticImportDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		List<String> list = new ArrayList<String>();
		
		list.add("abc3");
		list.add("abc7");
		list.add("abc1");
		
		out.println(list);
		
		sort(list);
		
		System.out.println(list);
		
		
		String max = max(list);
		System.out.println("max="+max);
		
	}

}