JAVA学习第四十三课 — 集合框架工具类(一)

一、Collections:集合框架的工具类

其中的方法都是静态的

排序方法演示

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class ComparaByLeng implements Comparator<String>{
	public int compare(String o1, String o2) {

		int t = o1.length() - o2.length();
		return t==0?o1.compareTo(o2):t;
	}
}
public class Main
{
	public static void main(String[] args) {
		Colletyions_Demo();
	}
	public static void Colletyions_Demo(){
		List<String> li = new ArrayList<String>();
		li.add("asd");    li.add("d");
		li.add("efasd");  li.add("efasd");
		li.add("dsssfd"); li.add("xxxxd");
		//System.out.println(list);
		//Collections.sort(list);//排序
		//System.out.println(list);
		//sort :public static <T extends Comparable<? super T>> void sort(List<T> list)
		//模拟sort
		//Mysort(list);
		//System.out.println(list);
		Mysort(li,new ComparaByLeng());
		System.out.println(li);
		Collections.sort(li,new ComparaByLeng());
		System.out.println(li);
	}
	/*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){
					Collections.swap(list, i, j);//工具类  交换
				}
			}
		}
	}	*/
	public static <T> void Mysort(List<T> li,Comparator<? super T> com) {
		for (int i = 0; i < li.size()-1; i++) {
			for (int j = i+1; j < li.size(); j++) {
				if(com.compare( li.get(i), li.get(j) ) > 0 ){
					Collections.swap(li, i, j);
				}
			}
		}
	}
}

二分查找、最值方法演示

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main
{
	public static void main(String[] args) {
		Colletyions_Demo();
	}
	public static void Colletyions_Demo(){
		List<String> li = new ArrayList<String>();
		li.add("asd");    li.add("d");
		li.add("efasd");  li.add("efasd");
		li.add("dsssfd"); li.add("xxxxd");

		Collections.sort(li);
		System.out.println(li);
		int index = Collections.binarySearch(li, "d");
		System.out.println(index);//负数代表没找到

		//获取最大值
		String maxstrString = Collections.max(li);
		System.out.println("max = "+maxstrString);
		//获取最小值
		String minstrString = Collections.min(li);
		System.out.println("min = "+minstrString);
		//取最长
		String maxlenString = Collections.max(li,new ComparaByLeng());
		System.out.println(maxlenString);
	}
}

逆转、替换方法演示

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.TreeSet;
public class Main
{
	public static void main(String[] args) {
		Colletyions_Demo();
	}
	public static void Colletyions_Demo(){
		//原理
//		TreeSet<String> ts = new TreeSet<String>(new Comparator<String>() {
//			public int compare(String o1, String o2) {
//
//				return o2.compareTo(o1);
//			}
//		});
		//封装后
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
		ts.add("ad");ts.add("xad");
		ts.add("fdagrrgd");ts.add("a");
		ts.add("gedsad");
		System.out.println(ts);
		//如果有比较器,逆转
		//长度逆转
		TreeSet<String> td = new TreeSet<String>(Collections.reverseOrder(new ComparaByLeng()));
		td.add("ad");td.add("xad");
		td.add("fdagrrgd");td.add("a");
		td.add("gedsad");
		System.out.println(td);
		//replaceAll / reverse方法
		List<String> al = new ArrayList<String>();
		al.add("ads");
		al.add("ds");
		al.add("s");
		Collections.reverse(al);
		System.out.println(al);
		Collections.replaceAll(al, "s", "y");//实际上 -> set(indexOf("s"),"y")
		System.out.println(al);
	}
}

其他方法

1、fill(List<? super T> list, T obj)

使用指定元素替换指定列表中的所有元素。

Collections.fill(list,"asd");

2、shuffle(List<?> list)

使用默认随机源对指定列表进行置换

Collections.shuffle(list);随机

更多方法看API文档。。。

将非同步集合转成同步集合的方法

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。

static

<K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)

返回指定有序映射支持的同步(线程安全的)有序映射。

static

<T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s)

返回指定有序 set 支持的同步(线程安全的)有序 set。

转换原理:

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

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

	private class MyList implements List{
		private List list;
		private static final Object lock = new Object();
		public MyList() {
			super();
			// TODO Auto-generated constructor stub
		}

		public MyList(List list) {
			super();
			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);
			}
		}
	}
}

时间: 2024-10-13 16:04:42

JAVA学习第四十三课 — 集合框架工具类(一)的相关文章

JAVA学习第四十四课 — 集合框架工具类(二)

Collections操控集合的工具类,Arrays操控数组的工具类 Arrays中方法大多是重载 重点掌握asList();将数组转为集合 static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表. import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { String[]

java学习笔记(十三)集合框架、用户界面

集合是一种对象,用于存储.检索.传输数据.由一组类和接口组成. 特点:类型可以不同,长度可变,空间不固定. 对象的存储类型:Set:一般情况下没有顺序,不能重复.List:有序,有重复对象,实现类通常支持null元素.Map:键值对,键.值不能重复,单向一对一关系. ArrayList:以数组方式实现,连续空间,查询效率高.LinkedList:以链表方式实现,增.删.改效率高. 泛型:允许在定义类,接口时指定类型形式参数.保证在集合中的元素类型安全. public class ArrayLis

黑马程序员——黑马基础——Map,集合框架工具类Conlections和Arrays

黑马程序员--黑马基础--Map,集合框架工具类Conlections和Arrays ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一,Map集合 Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key). 特点: 1)该集合存储键值对,一对一对往里存 2)要保证键的唯一性. Map集合的子类 Map |--Hashtable:底层是哈希表数据结构,不可以存入null键nu

集合框架工具类Collections

* Collections演示. * 1,用于操作集合的工具类. * 2,提供了很多的静态方法. * * 比如对list集合排序,二分查找,位置置换. * 对排序的元素进行顺序的逆转.reverseOrder * 还可以获取集合的最大值和最小值. * 最牛叉的是将非同步的集合转成同步的集合 synchronizedXXX package cn.itcast.p4.collections;   import java.util.ArrayList; import java.util.Collect

JAVA学习第三十三课(常用对象API)- 集合框架(一)

数字有很多用数组存,对象有很多就要用集合存 但是数组是固定长度的,集合是可变长度的 集合的由来: 对象用来封装特有数据,对象多了需要存储,如果对象个数不确定,就需要使用集合容器来存储 集合的特点: 1.用于存储对象的容器 2.长度可变 3.集合中不可存储基本数据类型 对于集合体系,的最顶层存储的是该体系中所有的共性内容,Collection,同继承一样,看顶层,用底层 java.uitil包中的Cellection 集合容器因为内部的数据不同,有多种具体容器,不断向上抽取,就形成了集合框架 整个

Java基础---泛型、集合框架工具类:collections和Arrays

第一讲     泛型(Generic) 一.概述 1.JDK1.5版本以后出现的新特性.用于解决安全问题,是一个类型安全机制. 2.JDK1.5的集合类希望在定义集合时,明确表明你要向集合中装入那种类型的数据,无法加入指定类型以外的数据. 3.泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时,会去掉“类型”信息,使程序运行效率不受影响,对参数化的泛型类型,getClass()方法的返回值和原始类型完全一样. 4.由于编译生成的字节码会去掉泛型的类型信息,只要能跳过编译器,就

黑马程序员——Java基础---集合框架工具类

黑马程序员——Java基础<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java为操作Set.List和Map提供了一系列工具类,主要有Collections和Arrays.这两个工具类的特点:类中的方法都是静态的,不需要创建对象,直接使用类名调用即可.Collections:是集合对象

黑马程序员---java基础---集合框架工具类:Collections和Arrays

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------        Collections 一.概述 Collections是对集合框架的一个工具类.它里边的方法都是静态的,不需要创建对象.并未封装特有数据. 在Collections工具类中大部分方法是用于对List集合进行操作的,如比较,二

JAVA 16(集合框架工具类)

Collections :工具类,专门对集合进行操作的.所有方法都是静态的,构造方法是私有的,不可以创建对象,通过Collections.xxx();调用工具类中的方法. 1, Collections.sort(); //对集合进行排序,List可以,Set不可以,因为有自动排序的TreeSet,其实是调用对象的Compare方法,如果想要排序自定义对象, sort后面要传入比较器. Collections.sort(list,new Strlen()); 下面有举例说明 2, Collecti