将 String 转换为 int 类型
int i = Integer.parseInt("1234");如何检查一个字符串是否为数字
使用 Apache Commons Lang 中的 StringUtils.isNumeric
String str = "1254";
boolean b =StringUtils.isNumeric(str);遍历HashMap中元素的最佳方法
public static void printMap(Map mp) {
Iterator it = mp.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pair = (Map.Entry)it.next();
System.out.println(pair.getKey() + " = " + pair.getValue());
it.remove(); // avoids a ConcurrentModificationException
}
}字符串转换为时间
String time = "2018:09:05 16:07:40";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss");
Date shootingTime = sdf.parse(time);json与Java对象互转采用com.alibaba.fastjson.JSON
Student类：public class Student {
//姓名
private String name;
//年龄
private String age;
//住址
private String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
", address='" + address + '\'' +
'}';
}
}
测试：
String objectStr="{\"name\":\"JSON\",\"address\":\"北京市西城区\"}";
Student s = JSON.parseObject(objectStr,Student.class);
System.out.println(s);
Student stu=new Student();
stu.setName("JSON");
stu.setAge("23");
stu.setAddress("北京市西城区");
String jsonStu = JSON.toJSONString(stu);
System.out.println(jsonStu);结果：
Student{name='JSON', age='null', address='北京市西城区'}
{"address":"北京市西城区","age":"23","name":"JSON"}
json字符串转化为Java对象数组：
List<Student> students = JSON.parseArray(jsonStr, Student.class);
将Java对象数组转化为json字符串
JSONArray.toJSON(students).toString();字符串转化为json，采用com.google.gson
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("GPSAltitude","123.98");
String jsonStr = jsonObject.toString();
System.out.println(jsonStr);
JsonObject jsonObject2 = new JsonObject();
jsonObject2.addProperty("GPSAl","123.928");
JsonArray jsonArray = new JsonArray();
jsonArray.add(jsonObject);
jsonArray.add(jsonObject2);
System.out.println(jsonArray);结果：
{"GPSAltitude":"123.98"}
[{"GPSAltitude":"123.98"},{"GPSAl":"123.928"}]
或采用 com.alibaba.fastjson
//下面是把拿到的json字符串转成 json对象
JSONObject jsStr = JSONObject.parseObject(jsonStr); //将字符串{“id”：1}
//int jsID = Integer.parseInt(jsStr.getString("id"));//获取id的值判断两个List是否相等，不保证顺序
/**
* 判断两个List集合中的数据是否相等，不保证顺序相等
*
* @param l0
* @param l1
* @return
*/
public static boolean isListEqual(List l0, List l1) {
if (l0 == l1) {
return true;
}
if (l0 == null && l1 == null) {
return true;
}
if (l0 == null || l1 == null) {
return false;
}
if (l0.size() != l1.size()) {
return false;
}
for (Object o : l0) {
if (!l1.contains(o)) {
return false;
}
}
for (Object o : l1) {
if (!l0.contains(o)) {
return false;
}
}
return true;
}或
boolean b = list0.containsAll(list1) && list1.containsAll(list0);边遍历边移除Collection中的元素
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
// do something
it.remove();
}若果写成下面的形式会报错
for(Integer i : list){
list.remove(i)
}报错：Exception in thread "main" java.util.ConcurrentModificationException
这是因为当使用foreach(for(Integer i : list))语句时，会自动生成一个iterator来遍历该list，但同时该list正在被Iterator.remove()修改。在Java中，一般不允许一个线程在遍历collection时另一个线程在修改它。
将List转化成int[]
很多人可能认为只需用List.toArray()即可，其实不然。List.toArray()方法只可能得到Integer[]，无法得到int[]。
最简单的方法是使用Apache Commons Lang库中的ArrayUtils。
int[] array = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));而且使用List.toArray()方法要注意：
List<Integer> list = new LinkedList<Integer>();
Object[] objArray = list.toArray();
Integer[] intArray = (Integer[]) objArray; //error当执行到第三句的时候，会抛出异常java.lang.ClassCastException。
如果想实现转化可以使用如下方式：
List<Integer> list = new LinkedList<Integer>();
Integer[] intArray = (Integer[]) list.toArray(new Integer[0]);将int[]转化成List
同上，很多人以为只需用Arrays.asList()即可，其实不然。因为不能以int[]作为该方法的参数，要的话也只能是Integer[]。
关于Arrays.asList()方法有如下特性：
- 1.该方法对于基本数据类型的数组支持并不好,当数组是基本数据类型时不建议使用
- 2.当使用asList()方法时，数组就和列表链接在一起了。当更新其中之一时，另一个将自动获得更新。因为asList获得的List实际引用的就是数组 注意:仅仅针对对象数组类型,基本数据类型数组不具备该特性。
- 3.asList得到的数组是的没有add和remove方法的。因为asList返回的List是Arrays中的内部类,而该类并没有定义add和remove方法。
那么如何将int[]转化成List呢？
还是得自己实现：
int[] array = {1,2,3,4,5};
List<Integer> list = new ArrayList<Integer>();
for(int i: array) {
list.add(i);
}将List转化成Set
有两种方法，取决于你怎么要怎么定义两个元素相等。第一种方法是将list放入HashSet里，该方法元素是否相等是通过它们的hashCode()来比较的。如果需要自己定义比较的方法，需要用TreeSet
Set<Integer> set = new HashSet<Integer>(list);
Set<Integer> set = new TreeSet<Integer>(aComparator);
set.addAll(list);删除ArrayList中重复的元素
Set<Integer> set = new HashSet<Integer>(list);
list.clear();
list.addAll(set);如果关心元素在ArrayList中的顺序，可以用LinkedHashSet。
根据类对象某一字段进行去重
代码示例：根据类code字段去重
public class RobotCase {
private Long caseId;
private Integer code;
private String clientName;
public Long getCaseId() {
return caseId;
}
public void setCaseId(Long caseId) {
this.caseId = caseId;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getClientName() {
return clientName;
}
public void setClientName(String clientName) {
this.clientName = clientName;
}
}private static List<RobotCase> removeDuplicateCase(List<RobotCase> cases) {
Set<RobotCase> set = new TreeSet<>(new Comparator<RobotCase>() {
@Override
public int compare(RobotCase o1, RobotCase o2) {
//升序排列
return o1.getCode().compareTo(o2.getCode());
}
});
set.addAll(cases);
return new ArrayList<>(set);
}有序的collection
Java里有很多方法来维持一个collection有序。有的需要实现Comparable接口，有的需要自己指定Comparator。
Collections.sort()可以用来对list排序。该排序是稳定的，并且可以保证nlog(n)的性能。PriorityQueue提供排序的队列。PriorityQueue和Collections.sort()的区别是，PriorityQueue动态维护一个有序的队列（每添加或删除一个元素就会重新排序），但是只能获队列中的头元素。- 如果collection中没有重复的元素，
TreeSet是另一个选择。跟PriorityQueue一样的是，TreeSet也动态维护一个有序的集合。可以从TreeSet中获取最大和最小的元素。
总结：Collections.sort()提供一个一次排序的list。PriorityQueue和TreeSet动态维护排序的collection。
拷贝list
有两种方法可以用来拷贝list。一种是使用ArrayList构造器。
ArrayList<Integer> dstList = new ArrayList<Integer>(srcList);另一种是使用Collections.copy()。
ArrayList<Integer> dstList = new ArrayList<Integer>(srcList.size());
Collections.copy(dstList, srcList);获取随机数
//方法1 (数据类型)
//(最小值+Math.random()*(最大值-最小值+1))
// 例:
(int)(1+Math.random()*(10-1+1)) //从1到10的int型随数
方法2 获得随机数
for (int i=0;i<30;i++)
{
System.out.println((int)(1+Math.random()*10));
}
(int)(1+Math.random()*10)
//通过java.Math包的random方法得到1-10的int随机数
//公式是:最小值---最大值（整数）的随机数 类型）最小值+Math.random()*最大值
方法3 Random ra =new Random();
for (int i=0;i<30;i++)
{System.out.println(ra.nextInt(10)+1);}
通过java.util包中的Random类的nextInt方法来得到1-10的int随机数
生成0到1之间的任意随机小数：
生成[0,d)区间的随机小数，d为任意正的小数，则只需要将nextDouble方法的返回值乘以d即可。
[n1，n2]
也就是 ra.nextDouble() * (n2-n1)+n1什么时候用LinkedList，什么时候用ArrayList？
ArrayList是使用数组实现的list，本质上就是数组。ArrayList中的元素可以通过索引随机获取一个元素。但是如果该数组已满，当添加新元素时需要分配一个新的数组然后将原来数组的元素移动过去，需要O(n)的时间复杂度。添加或删除一个元素需要移动数组中的其他元素。这是ArrayList最大的缺点。
LinkedList是一个双向链表。因此，当需要获取list中某个元素，需要从头到尾遍历list。另一方面，在链表中添加或删除元素很快，只需要O(1)的时间复杂度。从空间上来说，在链表中一个节点需要两个额外的指针来指向它的previous和next节点。
总结：
从时间复杂度来说，如果对list增加或删除操作较多，优先用LinkedList；如果查询操作较多，优先用ArrayList。
从空间复杂度来说，LinkedList会占用较多空间。
查找 List 中的最大最小值
List list = Arrays.asList("one Two three Four five six one three Four".split(" "));
System.out.println(list);
System.out.println("最大值: " + Collections.max(list));
System.out.println("最小值: " + Collections.min(list));
输出结果为：
[one, Two, three, Four, five, six, one, three, Four] 最大值: three 最小值: Four