cainiaoyu
- 浏览: 22009 次
- 性别:
- 来自: 杭州
-
最新评论
为了方便的对Array对象、Collection对象进行操作，Java中提供了Arrays类和Collections类对其进行操作。
Collections：是集合对象的工具类，提供了操作集合的工具方法
Arrays：是数组的工具类，提供了对数组的工具方法
其中Arrays和Collections中所有的方法都为静态的，不需要创建对象，直接使用类名调用即可。
Collections比较常用的方法：
1，为List集合进行排序Collections.sort()
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
class student implements Comparable {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(Object o){
if(!(o instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test{
public static void main(String[] args) {
ArrayList<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
//Collections.sort(al);如果存储的对象实现了comparable接口可以按照compareTo方法来排序
Collections.sort(al, new myComparator());//也可以根据自己比较器所定义的方法来排序
Iterator<student> it = al.iterator();
while (it.hasNext()) {
student s = it.next();
System.out.println(s.getname()+"!!"+s.getage());
}
}
}
class myComparator implements Comparator{
public int compare(Object o, Object o1) {
if(!(o instanceof student) || !(o1 instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
2，返回集合（List和Set）中的最大最小值：Collections.max和Collections.min
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
class student implements Comparable {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(Object o){
if(!(o instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test{
public static void main(String[] args) {
List<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
//student student = Collections.max(al, new myComparator());//按照自己定义的比较器内的方法来返回最大最小值
//student s1 = Collections.min(al,new myComparator());
student student = Collections.max(al);//按compareTo方法来返回最大最小值，返回的是具体存储的类型。
student s1 = Collections.min(al);
System.out.println(student.getname()+"+++++"+student.getage());
System.out.println(s1.getname()+"+++++"+s1.getage());
}
}
class myComparator implements Comparator{
public int compare(Object o, Object o1) {
if(!(o instanceof student) || !(o1 instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
3，对List集合进行二分查找：Collections.binarySearch，在此方法调用之前，需要先进行升序排序Collections.sort()。查询到返回位置否则返回-(index)-1。
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
class student implements Comparable<student> {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(student o){
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test {
public static void main(String[] args) {
List<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
Collections.sort(al);
//System.out.println(Collections.binarySearch(al, new student("zhangsan", 11)));//按自然顺序进行二分查找，返回1；
System.out.println(Collections.binarySearch(al, new student("zhangsan", 11),new myComparator()));//按比较器定义的顺序
}
}
class myComparator implements Comparator<student>{
public int compare(student o, student o1) {
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
4，反转集合内元素的顺序，reverse（反转List的顺序），reverseOrder（强行反转比较器的顺序）返回的是一个比较器
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
class student implements Comparable<student> {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(student o){
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test{
public static void main(String[] args) {
List<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
//Collections.sort(al,Collections.reverseOrder());//反转compareTo方法的顺序
//Collections.reverse(al);//针对List的反转方法
Collections.sort(al,Collections.reverseOrder(new myComparator()));//反转compare方法的顺序
Iterator<student> it = al.iterator();
while (it.hasNext()) {
student s = it.next();
System.out.println(s.getname()+"!!"+s.getage());
}
}
}
class myComparator implements Comparator<student>{
public int compare(student o, student o1) {
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
5，将集合类变成线程安全的（synchronizedCollection(Collection<T> c)、synchronizedList(List<T> list)、synchronizedMap(Map<K,V> m)、synchronizedSet(Set<T> s)）
源码：
public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<T>(list) :
new SynchronizedList<T>(list));
}
static <T> List<T> synchronizedList(List<T> list, Object mutex) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<T>(list, mutex) :
new SynchronizedList<T>(list, mutex));
}
/**
* @serial include
*/
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
static final long serialVersionUID = -7754090372962971524L;
final List<E> list;
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {
super(list, mutex);
this.list = list;
}
public boolean equals(Object o) {
synchronized(mutex) {return list.equals(o);}
}
public int hashCode() {
synchronized(mutex) {return list.hashCode();}
}
public E get(int index) {
synchronized(mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized(mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized(mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized(mutex) {return list.remove(index);}
}
public int indexOf(Object o) {
synchronized(mutex) {return list.indexOf(o);}
}
public int lastIndexOf(Object o) {
synchronized(mutex) {return list.lastIndexOf(o);}
}
public boolean addAll(int index, Collection<? extends E> c) {
synchronized(mutex) {return list.addAll(index, c);}
}
public ListIterator<E> listIterator() {
return list.listIterator(); // Must be manually synched by user
}
public ListIterator<E> listIterator(int index) {
return list.listIterator(index); // Must be manually synched by user
}
public List<E> subList(int fromIndex, int toIndex) {
synchronized(mutex) {
return new SynchronizedList<E>(list.subList(fromIndex, toIndex),
mutex);
}
}
通过定义一个内部类，并重写了List所有方法（调用初始化所传入的List所实现的方法），同时用相同的对象锁来保证同步。
Arrays常用的方法：
Arrays.binarySearch//二分查找
Arrays.copyOf //复制
Arrays.copyOfRange//复制部分
Arrays.sort//排序
Arrays.fill//填充
Arrays.toString//字符串返回
Arrays.hashCode//哈希值
Arrays.asList//将数组转为List
code
public class Test {
public static void main(String[] args) {
String arr[] = {"aaa","ccc","bb"};
List<String> list = Arrays.asList(arr);
System.out.println(list.contains("bb"));
int arr1[] = {1,2,3};
List<int[]> list1 = Arrays.asList(arr1);
System.out.println(arr1);
}
}
注：
1，将数组变成List，可以使用对集合的操作方法来操作数组，但是不可以对集合使用增删的操作（数组长度是固定的），否则会抛出UnsupportedOperationException异常；
2，如果数组中的元素都为对象，变成集合时，会直接将这些元素作为集合的元素；如果数组中的元素为基本类型，变成集合时，将以整体为集合的一个元素。
引申：Collection接口中有一个toArray方法，将集合转为数组
code
public class Test{
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("aaa");
al.add("ccc");
al.add("dd");
String s[] = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(s));
}
}
注：
1，指定类型数组的大小小于集合的size（）时，toArray方法会内部新建一个数组。当长度大于或等于集合的Size时，则直接使用传递进来的数组。
2，集合变成数组可以限定对集合中元素的操作。（数组长度不可变）
jdk1.5新特性
Collection就有了一个父接口Iterable
该接口的出现封装了iterator方法，并提供了一个增强型的for循环
格式：
for(元素类型 变量 ：数组或者Collection集合)
{
}
code
public class Test {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("aaa");
al.add("ccc");
al.add("dd");
for (String string : al) {
System.out.println(string);
}
}
}
注：使用增强性for循环只能获取集合元素，不能对集合中的元素进行操作，迭代器在遍历中还可以进行remove操作
增强for循环和传统for循环区别：
增强for循环，使用时，必须要有被遍历的目标
而且只能遍历数组和Collection集合，简化了迭代
传统for循环，使用更加普遍
注意：遍历数组还是使用传统for循环，这样可以通过指针对数组中的元素进行操作
可变参数
在指定数据类型的后面加上三个点，其实就是一个数组类型的参数
以前定义一个int[]类型 参数，调用必须要定义好一个数组，再往里传递
而现在定义一个int…类型的参数，调用者，直接往该函数里传递元素即可
在运行时，自动会将这些实际参数封装到一个该类型的数组中。
注意：如果函数上有多个参数，可变参数一定要定义在参数列表最后边，否则编译失败
code
public class Test{
public static void main(String[] args) {
show(2,2,3,4);
}
public static void show(int... arr) {
System.out.println(Arrays.toString(arr));
}
}
Collections：是集合对象的工具类，提供了操作集合的工具方法
Arrays：是数组的工具类，提供了对数组的工具方法
其中Arrays和Collections中所有的方法都为静态的，不需要创建对象，直接使用类名调用即可。
Collections比较常用的方法：
1，为List集合进行排序Collections.sort()
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
class student implements Comparable {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(Object o){
if(!(o instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test{
public static void main(String[] args) {
ArrayList<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
//Collections.sort(al);如果存储的对象实现了comparable接口可以按照compareTo方法来排序
Collections.sort(al, new myComparator());//也可以根据自己比较器所定义的方法来排序
Iterator<student> it = al.iterator();
while (it.hasNext()) {
student s = it.next();
System.out.println(s.getname()+"!!"+s.getage());
}
}
}
class myComparator implements Comparator{
public int compare(Object o, Object o1) {
if(!(o instanceof student) || !(o1 instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
2，返回集合（List和Set）中的最大最小值：Collections.max和Collections.min
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
class student implements Comparable {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(Object o){
if(!(o instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test{
public static void main(String[] args) {
List<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
//student student = Collections.max(al, new myComparator());//按照自己定义的比较器内的方法来返回最大最小值
//student s1 = Collections.min(al,new myComparator());
student student = Collections.max(al);//按compareTo方法来返回最大最小值，返回的是具体存储的类型。
student s1 = Collections.min(al);
System.out.println(student.getname()+"+++++"+student.getage());
System.out.println(s1.getname()+"+++++"+s1.getage());
}
}
class myComparator implements Comparator{
public int compare(Object o, Object o1) {
if(!(o instanceof student) || !(o1 instanceof student))
throw new RuntimeException("不是学生");
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
3，对List集合进行二分查找：Collections.binarySearch，在此方法调用之前，需要先进行升序排序Collections.sort()。查询到返回位置否则返回-(index)-1。
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
class student implements Comparable<student> {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(student o){
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test {
public static void main(String[] args) {
List<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
Collections.sort(al);
//System.out.println(Collections.binarySearch(al, new student("zhangsan", 11)));//按自然顺序进行二分查找，返回1；
System.out.println(Collections.binarySearch(al, new student("zhangsan", 11),new myComparator()));//按比较器定义的顺序
}
}
class myComparator implements Comparator<student>{
public int compare(student o, student o1) {
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
4，反转集合内元素的顺序，reverse（反转List的顺序），reverseOrder（强行反转比较器的顺序）返回的是一个比较器
code
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
class student implements Comparable<student> {
private int age;
private String name;
public student(String name ,int age) {
this.name = name;
this.age = age;
}
public String getname() {
return name;
}
public int getage(){
return age;
}
public int compareTo(student o){
student s = (student) o;
System.out.println(this.name+"-----"+s.name);
int num = new Integer(this.age).compareTo(s.age);
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
public class Test{
public static void main(String[] args) {
List<student> al= new ArrayList<student>();
al.add(new student("zhangsan", 11));
al.add(new student("lisi", 12));
al.add(new student("wangwu", 11));
//Collections.sort(al,Collections.reverseOrder());//反转compareTo方法的顺序
//Collections.reverse(al);//针对List的反转方法
Collections.sort(al,Collections.reverseOrder(new myComparator()));//反转compare方法的顺序
Iterator<student> it = al.iterator();
while (it.hasNext()) {
student s = it.next();
System.out.println(s.getname()+"!!"+s.getage());
}
}
}
class myComparator implements Comparator<student>{
public int compare(student o, student o1) {
student s = (student) o;
student s1 = (student) o1;
System.out.println(s.getname()+"-----"+s1.getname());
int num = new Integer(s.getage()).compareTo(s1.getage());
if(num == 0)
return s.getname().compareTo(s1.getname());
return num;
}
}
5，将集合类变成线程安全的（synchronizedCollection(Collection<T> c)、synchronizedList(List<T> list)、synchronizedMap(Map<K,V> m)、synchronizedSet(Set<T> s)）
源码：
public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<T>(list) :
new SynchronizedList<T>(list));
}
static <T> List<T> synchronizedList(List<T> list, Object mutex) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<T>(list, mutex) :
new SynchronizedList<T>(list, mutex));
}
/**
* @serial include
*/
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
static final long serialVersionUID = -7754090372962971524L;
final List<E> list;
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {
super(list, mutex);
this.list = list;
}
public boolean equals(Object o) {
synchronized(mutex) {return list.equals(o);}
}
public int hashCode() {
synchronized(mutex) {return list.hashCode();}
}
public E get(int index) {
synchronized(mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized(mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized(mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized(mutex) {return list.remove(index);}
}
public int indexOf(Object o) {
synchronized(mutex) {return list.indexOf(o);}
}
public int lastIndexOf(Object o) {
synchronized(mutex) {return list.lastIndexOf(o);}
}
public boolean addAll(int index, Collection<? extends E> c) {
synchronized(mutex) {return list.addAll(index, c);}
}
public ListIterator<E> listIterator() {
return list.listIterator(); // Must be manually synched by user
}
public ListIterator<E> listIterator(int index) {
return list.listIterator(index); // Must be manually synched by user
}
public List<E> subList(int fromIndex, int toIndex) {
synchronized(mutex) {
return new SynchronizedList<E>(list.subList(fromIndex, toIndex),
mutex);
}
}
通过定义一个内部类，并重写了List所有方法（调用初始化所传入的List所实现的方法），同时用相同的对象锁来保证同步。
Arrays常用的方法：
Arrays.binarySearch//二分查找
Arrays.copyOf //复制
Arrays.copyOfRange//复制部分
Arrays.sort//排序
Arrays.fill//填充
Arrays.toString//字符串返回
Arrays.hashCode//哈希值
Arrays.asList//将数组转为List
code
public class Test {
public static void main(String[] args) {
String arr[] = {"aaa","ccc","bb"};
List<String> list = Arrays.asList(arr);
System.out.println(list.contains("bb"));
int arr1[] = {1,2,3};
List<int[]> list1 = Arrays.asList(arr1);
System.out.println(arr1);
}
}
注：
1，将数组变成List，可以使用对集合的操作方法来操作数组，但是不可以对集合使用增删的操作（数组长度是固定的），否则会抛出UnsupportedOperationException异常；
2，如果数组中的元素都为对象，变成集合时，会直接将这些元素作为集合的元素；如果数组中的元素为基本类型，变成集合时，将以整体为集合的一个元素。
引申：Collection接口中有一个toArray方法，将集合转为数组
code
public class Test{
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("aaa");
al.add("ccc");
al.add("dd");
String s[] = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(s));
}
}
注：
1，指定类型数组的大小小于集合的size（）时，toArray方法会内部新建一个数组。当长度大于或等于集合的Size时，则直接使用传递进来的数组。
2，集合变成数组可以限定对集合中元素的操作。（数组长度不可变）
jdk1.5新特性
Collection就有了一个父接口Iterable
该接口的出现封装了iterator方法，并提供了一个增强型的for循环
格式：
for(元素类型 变量 ：数组或者Collection集合)
{
}
code
public class Test {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("aaa");
al.add("ccc");
al.add("dd");
for (String string : al) {
System.out.println(string);
}
}
}
注：使用增强性for循环只能获取集合元素，不能对集合中的元素进行操作，迭代器在遍历中还可以进行remove操作
增强for循环和传统for循环区别：
增强for循环，使用时，必须要有被遍历的目标
而且只能遍历数组和Collection集合，简化了迭代
传统for循环，使用更加普遍
注意：遍历数组还是使用传统for循环，这样可以通过指针对数组中的元素进行操作
可变参数
在指定数据类型的后面加上三个点，其实就是一个数组类型的参数
以前定义一个int[]类型 参数，调用必须要定义好一个数组，再往里传递
而现在定义一个int…类型的参数，调用者，直接往该函数里传递元素即可
在运行时，自动会将这些实际参数封装到一个该类型的数组中。
注意：如果函数上有多个参数，可变参数一定要定义在参数列表最后边，否则编译失败
code
public class Test{
public static void main(String[] args) {
show(2,2,3,4);
}
public static void show(int... arr) {
System.out.println(Arrays.toString(arr));
}
}
分享到：
发表评论
-
java-HashMap
2014-04-09 01:17 0HashMap继承AbstractMap并实现Map接口。类图 ... -
Java中多线程与多线程同步
2014-04-07 21:25 0多线程的目的： 多线程实现了程序的并发执行。 Java 中线程 ... -
Java多线程通信
2014-04-07 21:21 454上一篇介绍Java提供synchr ... -
Java集合类（Set和List）
2014-04-07 21:15 588java提供两种存储对象的方式：数组和集合类。 两者的主要区别 ... -
Java-io小结
2014-04-07 20:37 474Java处理的数据流主要分为字节流和字符流。字符流处理的单元为 ... -
SQL小结
2014-04-07 16:29 562<转>[size=medium][/size] 结 ... -
hibernate缓存
2014-03-18 18:52 407hibernate缓存深入详解 -
SSH总结
2014-03-17 18:39 520struts hibernate spring -
sql order by 排序控制
2013-10-17 16:49 550SELECT * FROM table ta order ... -
在线代码格式化
2013-08-26 16:42 616http://www.ostools.net/ -
判断java中string型变量是否为空
2013-08-12 19:02 543<s:if test='actionItem.deleg ... -
多浏览器兼容问题 IE Firefox Chrome
2013-08-12 18:39 1405[size=x-large]在测试与各个浏览器兼容性的 ... -
Cron4j Scheduler
2012-07-06 18:15 3490Cron4j is a scheduler for the ... -
Integrating Jasypt with Hibernate
2012-06-25 18:29 2003[size=medium]Integrating Jasypt ...
相关推荐
- `ListUtils`和`MapUtils`：Apache Commons Collections中的工具类，提供了集合的创建、合并、分割等高级操作。 6. **反射工具类**： - `ClassUtils`：Apache Commons Lang库中的工具类，提供类的加载、属性检查...
下面我们将详细探讨Java中28个常用的工具类，主要涉及`IO`相关的开发工具。 1. **java.lang.Math**：这个类提供了许多基础数学函数，如求平方根、最大值、最小值、随机数生成等。 2. **java.util.Arrays**：用于...
Collections是操作集合对象的工具类 Objects是操作引用数据类型对象的工具类 Arrays的常用方法 普通排序 Arrays.sort(int[] a) Arrays.sort(int[] a, int fromIndex, int toIndex) 并行排序:JDK1.8新增 Arrays....
在Java编程语言中，工具类集合是一组预定义的、静态方法丰富的类，它们提供了各种实用功能，大大简化了开发人员的工作。这些工具类通常包含在Java标准库（JDK）的不同包中，如`java.util`、`java.lang`、`java.io`等...
常用的集合类Iterator迭代器的使用foreach循环 泛型Collections、Arrays工具
在Java编程语言中，工具类集合是一系列实用的类，它们提供了各种通用功能，帮助开发者更高效地编写代码。这些工具类通常包含在Java的`java.util`以及其他相关的包中，如`java.text`，`javax.imageio`，`javax.xml`等...
在Java编程语言中，工具类（Utils）是包含各种实用方法的类，这些方法通常用于执行常见的任务，如类型转换、字符串操作、集合处理等。它们使得代码更加简洁且易于维护，因为它们提供了通用功能的封装，避免了重复...
8. **实用工具类**：如Arrays、Collections和Guava库中的工具类，它们提供了丰富的静态方法来处理集合。 通过阅读"Java Generics and Collections"，开发者不仅可以掌握Java泛型和集合的基本使用，还能深入了解它们...
10. **HashMap和HashSet类**：这两个集合类提供键值对和不重复元素的存储，常用于数据结构的实现。 11. **ArrayList和LinkedList类**：两种不同的列表实现，ArrayList基于数组，适合随机访问；LinkedList基于链表，...
Java工具类是Java编程语言中一个非常重要的组成部分，它们提供了许多实用的方法，帮助开发者更高效地处理各种编程任务。在Java中，工具类通常被设计为静态方法集合，不依赖于实例化对象，可以直接调用类中的方法进行...
- `java.util.Date` 和 `java.util.Calendar`：这两个类是Java早期用于处理日期和时间的基础类，但设计上存在一些问题，如非线程安全和API复杂。 - `java.time` 包：Java 8引入的新时间日期API，包含`LocalDate`, ...
2. **`java.util.Collections`**：与`Arrays`对应，`Collections`提供了一组针对集合的操作方法，如排序、反转、查找和集合转换。`Collections.sort()`可对列表进行排序，而`Collections.synchronizedXXX()`方法用于...
在Java中，最著名的工具类库是`java.util`包，它包含了大量实用类，如集合、日期时间、数学计算、线程管理等。此外，还有一些第三方库，如Apache Commons Lang、Guava等，提供了更丰富的功能。 1. **java.util包**...
在Java编程语言中，工具类（Utility Class）是封装了常用功能的方法集合，它们通常以静态方法的形式提供，便于开发者快速调用。这些工具类极大地提高了开发效率，减少了代码重复，使得程序更加简洁、易读。以下是...
1. 集合框架：Java中的集合框架是`java.util`包的核心，包括List、Set、Queue和Map等接口，以及ArrayList、LinkedList、HashSet、HashMap等实现类。它们提供了存储和操作对象的基本功能，支持动态扩展和多种操作，如...
在这个名为"牛逼的java常用工具类"的压缩包中，我们可以期待找到一些由经验丰富的开发者精心设计和优化的工具类，这些工具类能极大地提高开发效率，减少代码量，使程序更加健壮。下面，我们将详细探讨一些可能包含在...
本文主要探讨两个重要的工具类：Arrays和Collections，它们分别针对数组和集合提供了丰富的操作方法。 一、Arrays工具类 Arrays工具类位于`java.util`包下，主要用于对数组进行各种操作。以下是一些常用的方法： ...
下面将详细介绍标题和描述中提到的30个Java工具类，并阐述它们的主要功能和使用场景。 1. **Arrays**: 提供排序、比较和搜索数组的方法，如`Arrays.sort()`、`Arrays.equals()`和`Arrays.binarySearch()`。 2. **...
JavaUtils工具类是Java开发中常见的一类辅助代码集合，它们通常包含各种静态方法，用于简化常见的编程任务，提高开发效率。这篇博文链接（已提供但无法直接访问）可能详细探讨了JavaUtils工具类的设计原则、常用方法...
在Java编程语言中，工具类（Utility Class）是包含各种静态方法的类，这些方法通常用于执行特定的、重复的任务，以提高代码的重用性和效率。这些工具类不依赖于实例化，而是通过调用静态方法来提供服务。下面我们将...