Java:集合框架的工具类
集合框架的工具类
Arrays:里面都是静态方法,直接用来对各种集合进行操作的公有方法。
Collections:里面都是静态方法,直接用来对各种集合进行操作的公有方法。
包括:
1、asList将数组变成list集合:
static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。
//例子1:
import java.util.*;
class ArraysTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
BasicTypetolist();
ObjecttoList();
tostring();
} public static void tostring()
{
String[] str = {"aaa","bc","kkkk","qq"}; //字符串形式返回数组内容
sop(Arrays.toString(str));
} public static void BasicTypetolist()
{
int[] nums = {4,8,9,10};
List<int[]> list = Arrays.asList(nums);
sop(list);
/*
数组中的元素如果是对象,那么数组变成集合后,数组中的元素就直接变为集合中的元素存在;
数组中的元素如果是基本数据类型,那么数组变成集合后,数组就直接变为集合中的元素存在;
*/
//Integer[] inte = {4,8,9,10};
//List<Integer> list = Arrays.asList(inte);
//sop(list);
} public static void ObjecttoList()
{
String[] str = {"aaa","bc","kkkk","qq"}; //将字符数组转换为集合
/*
好处:可以使用集合中的思想来操作数组。
注意:将数组变成集合,不可以使用集合的增删操作方法.因为数组的长度是固定的。
如果进行增删操作,就会产生不支持操作异常...
*/
List<String> list = Arrays.asList(str);
sop("contains:"+list.contains("qq")); // sop(list.add("zz"));//UnsupportedOperationException
sop(list);
}
}
2、二分方查找:
基本数据类型:byte、short、int、double、float、long、char
static int binarySearch(基本数据类型[] a, 基本数据类型 key)
使用二分搜索法来搜索指定的基本数据类型数组类型数组,以获得指定的值。
static int binarySearch(基本数据类型[] a, int fromIndex, int toIndex, 基本数据类型 key)
使用二分搜索法来搜索指定的基本数据类型数组类型数组的范围,以获得指定的值。
static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
使用二分搜索法来搜索指定数组的范围,以获得指定对象。
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)
使用二分搜索法来搜索指定数组,以获得指定对象。
//例子2:
import java.util.*;
class CollectionsbinarySearch
{
public static void main(String[] args)
{
binarySearchdemo1();
binarySearchdemo2();
}
public static void binarySearchdemo1()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("cdefg");
list.add("kkkkkkk");
list.add("qq");
sop("list:"+list);
Collections.sort(list);
sop("list:"+list); //使用二分搜索法搜索指定列表,以获得指定对象。
sop("index="+Collections.binarySearch(list,"z")+"\n");
} public static void binarySearchdemo2()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("cdefg");
list.add("kkkkkkk");
list.add("qq");
sop("list:"+list);
Collections.sort(list,new Mycomparator());
sop("list:"+list); //使用二分搜索法搜索指定列表,(按照比较器)以获得指定对象。
sop("index="+Collections.binarySearch(list,"z",new Mycomparator())); } public static<T> void sop(T t)
{
System.out.println(t);
}
} class Mycomparator implements Comparator<String> ////定义一个比较器
{
public int compare(String str1,String str2)
{
int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
return num==0? str1.compareTo(str2):num;
}
}
3、复制指定的数组:
基本数据类型:boolean、byte、short、int、double、float、long、char
static 基本数据类型[] copyOf(基本数据类型[] original, int newLength)
复制指定的数组,截取或用 0或false或null填充(如有必要),以使副本具有指定的长度。
static <T> T[] copyOf(T[] original, int newLength)
复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。
static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType)
复制指定的数组,截取或用 null 填充(如有必要),以使副本具有指定的长度。
4、将指定原数组范围复制到新数组 :
基本数据类型:boolean、byte、short、int、double、float、long、char
static 基本数据类型[] copyOfRange(基本数据类型[] 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)
将指定数组的指定范围复制到一个新数组。
5、比较两个数组中的内容是否相同。
基本数据类型:boolean、byte、short、int、double、float、long、char
static boolean equals(基本数据类型[] a, 基本数据类型[] a2)
如果两个指定的基本数据类型数组彼此相等,则返回 true。
static boolean deepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的,则返回 true。
6、返回数组的哈希值。
基本数据类型:boolean、byte、short、int、double、float、long、char
static int hashCode(基本数据类型[] a)
基于指定数组的内容返回哈希码。
static int deepHashCode(Object[] a)
基于指定数组的“深层内容”返回哈希码。
7、以字符串形式返回数组内容。
基本数据类型:boolean、byte、short、int、double、float、long、char
static String toString(基本数据类型[] a)
返回指定数组内容的字符串表示形式。
static String toString(Object[] a)
返回指定数组内容的字符串表示形式。
static String deepToString(Object[] a)
返回指定数组“深层内容”的字符串表示形式。
//例子7:
import java.util.*;
class CollectionToArray
{
public static<T> void sop(T t)
{
System.out.println(t);
}
public static void main(String[] args)
{
colletiontoarray();
}
public static void colletiontoarray()
{
ArrayList<String> al = new ArrayList<String>(); al.add("abc");
al.add("bcd");
al.add("kef");
/*
1、 指定类型的数组到底要多长呢?
当指定类型的数组长度小于集合的Size,那么该方法内部会创建一个新的数组,长度为集合的size
当指定类型的数组长度大于集合的Size,就不会再创建新数组。而是直接使用传递进来的数组。
所以创建一个刚刚好的数组长度最好。即 集合.size()。 2、 为什么要将集合变成数组呢?
为了限制对集合中的元素进行操作。不需要再进行增删了。
*/ String[] str1 = al.toArray(new String[0]);
sop(Arrays.toString(str1));//结果是:[abc,bcd,kef] String[] str2 = al.toArray(new String[5]);
sop(Arrays.toString(str2));//结果是:[abc,bcd,kef,null,null] String[] str3 = al.toArray(new String[al.size()]);
sop(Arrays.toString(str3));//结果是:[abc,bcd,kef]
}
}
8、用内容替换数组指定索引的内容、反转、替换 、交换
基本数据类型:boolean、byte、short、int、double、float、long、char
static void fill(基本数据类型[] a, int fromIndex, int toIndex, 基本数据类型 val)
将指定的基本数据类型值分配给指定基本数据类型数组指定范围中的每个元素。
static void fill(基本数据类型[] a, 基本数据类型 val)
将指定的基本数据类型值分配给指定基本数据类型数组的每个元素。
static void fill(Object[] a, int fromIndex, int toIndex, Object val)
将指定的 Object 引用分配给指定 Object 数组指定范围中的每个元素。
static void fill(Object[] a, Object val)
将指定的 Object 引用分配给指定 Object 数组的每个元素。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list)
反转指定列表中元素的顺序。
static void swap(List<?> list, int i, int j)
在指定列表的指定位置处交换元素。
//例子8:
import java.util.*;
class CollectionsFillReverseReplace
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
filldemo();
replaceAlldemo();
reversedemo();
}
public static void filldemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop("list:"+list); //使用指定元素替换指定列表中的所有元素。
Collections.fill(list,"pp");
sop("list:"+list+"\n");
} public static void replaceAlldemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("zz");
list.add("kkkkk");
sop("list:"+list); //使用另一个值替换列表中出现的所有某一指定值。
sop(Collections.replaceAll(list,"zz","yy"));
sop("list:"+list+"\n");
} public static void reversedemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop("list:"+list); //反转指定列表中元素的顺序。
Collections.reverse(list);
sop("list:"+list);
} public static void swapdemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop("list:"+list); //在指定列表的指定位置处(0和3位置处元素交换)交换元素。
Collections.swap(list,0,3);
sop("list:"+list);
} }
9、排序:
基本数据类型:byte、short、int、double、float、long、char
static void sort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。
static void sort(Object[] a, int fromIndex, int toIndex)
根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static void sort(基本数据类型[] a)
对指定的基本数据类型数组按数字升序进行排序。
static void sort(基本数据类型[] a, int fromIndex, int toIndex)
对指定基本数据类型数组的指定范围按数字升序进行排序。
static <T> void sort(T[] a, Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组进行排序。
static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
//例子9
import java.util.*;
class CollectionsSort
{
public static void main(String[] args)
{
sortdemo();
}
public static void sortdemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("cdefg");
list.add("kkkkkkk");
list.add("qq");
list.add("qq"); sop(list); //排序前
Collections.sort(list);
sop(list); //排序后 Collections.sort(list,new Mycomparator());
sop(list); //传入比较器排序后
}
public static<T> void sop(T t)
{
System.out.println(t);
}
}
class Mycomparator implements Comparator<String> //定义一个比较器
{
public int compare(String str1,String str2)
{
int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
return num==0? str1.compareTo(str2):num;
}
} /*
List<Student> list = new ArrayList<Student>();
list.add(new Student()); class Student
{ } public static<T extends Comparable <? super T>> void sort(List<Student> list) //接受的对象泛型T必须具备比较性,所以
{ //可以继承Comparable, }
*/
10.逆转比较器:
static <T> Comparator<T> reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强行逆转指定比较器的顺序。
//例子10:
import java.util.*;
class ReverseOrder
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Set<String> ts1 = new TreeSet<String>();
ts1.add("abcde");
ts1.add("aaa");
ts1.add("k");
ts1.add("cc"); sop("自然顺序排序:");
Iterator<String> it1 = ts1.iterator();
while(it1.hasNext())
{
String str = it1.next();
sop(str);
} reverseorderdemo1(); Set<String> ts2 = new TreeSet<String>(new Mycomparator());
ts2.add("abcde");
ts2.add("aaa");
ts2.add("k");
ts2.add("cc"); sop("自定义字符串长度顺序排序:");
Iterator<String> it2 = ts2.iterator();
while(it2.hasNext())
{
String str = it2.next();
sop(str);
}
reverseorderdemo2();
} public static void reverseorderdemo1()
{
Set<String> ts = new TreeSet<String>(Collections.reverseOrder());
ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc"); //返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
//Comparator co = Collections.reverseOrder(); sop("返回比较器后,逆转自然顺序排序:");
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
String str = it.next();
sop(str);
}
} public static void reverseorderdemo2()
{
Set<String> ts = new TreeSet<String>(Collections.reverseOrder(new Mycomparator()));
ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc"); //返回一个比较器,它强行逆转指定比较器的顺序(假如之前自定义设定的按照字符串长度)。
//Comparator co = Collections.reverseOrder(new Mycomparator()); sop("返回比较器后,逆转自定义字符串长度顺序排序:");
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
String str = it.next();
sop(str);
}
}
} class Mycomparator implements Comparator<String> ////定义一个比较器
{
public int compare(String str1,String str2)
{
int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
return num==0? str1.compareTo(str2):num;
}
}
11、Collections:里面都是静态方法,直接用来对各种集合进行操作的公有方法。
例如(求集合元素最值):
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据元素的自然顺序,返回给定 collection 的最大元素。
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序,返回给定 collection 的最大元素。
static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
根据元素的自然顺序 返回给定 collection 的最小元素。
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序,返回给定 collection 的最小元素
//例子11:
import java.util.*;
class CollectionsMaxMin
{
public static void main(String[] args)
{
maxdemo();
mindemo();
}
public static void maxdemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("cdefg");
list.add("kkkkkkk");
list.add("qq");
list.add("qq");
sop("list:"+list);
Collections.sort(list);
sop(list); //根据元素的自然顺序,返回给定ArrayList集合中的最大元素
String s1 = Collections.max(list);
sop("max1="+s1); //根据指定比较器产生的顺序,返回给定ArrayList的最大元素(返回最长的字符串)。
String s2 = Collections.max(list,new Mycomparator());
sop("max2="+s2);
} public static void mindemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("z");
list.add("cdefg");
list.add("kkkkkkk");
list.add("qq");
list.add("qq");
sop("list:"+list);
Collections.sort(list);
sop(list); //根据元素的自然顺序,返回给定ArrayList集合中的最小元素
String s1 = Collections.min(list);
sop("min1="+s1); //根据指定比较器产生的顺序,返回给定ArrayList的最小元素(返回最短的字符串)。
String s2 = Collections.min(list,new Mycomparator());
sop("min2="+s2);
} public static<T> void sop(T t)
{
System.out.println(t);
}
} class Mycomparator implements Comparator<String> ////定义一个比较器
{
public int compare(String str1,String str2)
{
int num = new Integer(str1.length()).compareTo(new Integer(str2.length()));
return num==0? str1.compareTo(str2):num;
}
}
12、Collections:里面都是静态方法,直接用来对各种集合进行操作的公有方法。
例如(集合加锁,让线程同步、随机排序):
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。
static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list, Random rnd)
使用指定的随机源对指定列表进行置换。
//例子12:
import java.util.*;
class CollectionsSynchronizedShuffle
{
public static<T> void sop(T t)
{
System.out.println(t);
}
public static void main(String[] args)
{
shuffledemo();
}
public static void shuffledemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop("list:"+list); //使用默认随机源对指定列表进行置.(每一次运行结果可能都不一样)
Collections.shuffle(list);
sop("list:"+list+"\n");
}
}
Java:集合框架的工具类的更多相关文章
- 【JAVA集合框架之工具类】
一.概述 JAVA集合框架中有两个很重要的工具类,一个是Collections,另一个是Arrays.分别封装了对集合的操作方法和对数组的操作方法,这些操作方法使得程序员的开发更加高效. public ...
- Java最重要的21个技术点和知识点之JAVA集合框架、异常类、IO
(三)Java最重要的21个技术点和知识点之JAVA集合框架.异常类.IO 写这篇文章的目的是想总结一下自己这么多年JAVA培训的一些心得体会,主要是和一些java基础知识点相关的,所以也希望能分享 ...
- Java集合框架(常用类) JCF
Java集合框架(常用类) JCF 为了实现某一目的或功能而预先设计好一系列封装好的具有继承关系或实现关系类的接口: 集合的由来: 特点:元素类型可以不同,集合长度可变,空间不固定: 管理集合类和接口 ...
- Java 集合框架工具类
Collections Arrays Collections 集合框架的工具类, 里面的方法都是静态的, 可以直接使用类名调用 常用方法 1. sort(List<T> list); // ...
- Java集合框架(四)
Collections 集合框架的工具类 着重讲解以下方法: 1.sort(): 1º根据元素的自然顺序对指定列表按升序进行排序,列表中的所有元素都必须实现comparable接口. pu ...
- Java集合框架体系详细梳理,含面试知识点。
一.集合类 集合的由来: 面向对象语言对事物都是以对象的形式来体现,为了方便对多个对象的操作,就需要将对象进行存储,集合就是存储对象最常用的一种方式. 集合特点: 1,用于存储对象的容器.(容器本身就 ...
- 集合中的工具类Collections和Arrays
集合框架的工具类: Collections: 方法sort(): List<String> list = new ArrayList<String>(); lis ...
- 12:集合map、工具类
一.map集合 Map:一次添加一对元素.Collection 一次添加一个元素. Map也称为双列集合,Collection集合称为单列集合. 其实map集合中存储的就是键值对(结婚证书), map ...
- java集合框架——工具类
一.概述 JAVA集合框架中有两个很重要的工具类,一个是Collections,另一个是Arrays.分别封装了对集合的操作方法和对数组的操作方法,这些操作方法使得程序员的开发更加高效. public ...
随机推荐
- ios应运程序的五种状态
ios应运程序的五种状态即转化 从apple的官方文档扣下来的 5状态: Not running The app has not been launched or was running but w ...
- 对中级Linux用户有用的20个命令
1. 命令: Find 搜索指定目录下的文件,从开始于父目录,然后搜索子目录. 注意: -name‘选项是搜索大小写敏感.可以使用-iname‘选项,这样在搜索中可以忽略大小写.(*是通配符,可以搜索 ...
- android activity之间传递返回值
activity A,跳转至 Activity B ,A传参数user_name给B,然后B再返回修改后的参数user_name给A 首先A传user_name给B Intent input_B = ...
- CSS3中box-shadow的用法介绍
一般我们通过box-shadow来设置盒阴影,但是有些属性我们一般没有用到,这篇文章将对box-shadow属性进行逐个分析.语法 CSS Code复制内容到剪贴板 E {box-shadow:ins ...
- shell编程之数组和关联数组
一.数组类似c语言的数组 1.两种赋值方式 可以整体定义数组:ARRAY_NAME=(value0 value1 value2 value3 ...) 此时数组的下标默认是从0开始的 还可以单独定义数 ...
- 一个包的libevent流程
//一个发包的流程 第一个包就是客户端的心跳包,现在加了版本的包 再来看看这个发包打包过程,过程坚持,但理解费劲 void NGP::OnliveTimer()//客户端心跳,5s发一次 { Send ...
- linux centos yum 安装 rar
linux yum安装rar时,可能会出现无资源的错误,只需把配置好资源即可,具体操作如下: 1.# vi /etc/yum.repos.d/dag.repo 2.将以下内容写入文件中 [dag] n ...
- <context:annotation-config> 跟 <context:component-scan>诠释及区别
<context:annotation-config> 是用于激活那些已经在spring容器里注册过的bean(无论是通过xml的方式还是通过package sanning的方式)上面的注 ...
- 异步任务(AsyncTask)
1.Android UI组件更新简介 Android的UI线程主要负责处理用户的按键事件.用户触屏事件及屏幕绘图事件等,因此开发者的其它操作不应该,也不能阻塞UI线程,否则UI界面将会变的停止响应.A ...
- Effeckt.css项目:CSS交互动画应用集锦
目前,网上有大量基于CSS转换的实验和示例,但它们都过于分散,而Effeckt.css的目标就是把所有基于CSS/jQuery动画的应用集中起来,例如:弹窗.按钮.导航.列表.页面切换等等. Effe ...