java --list工具

最新推荐文章于 2024-05-11 23:39:29 发布

qiuJun998

最新推荐文章于 2024-05-11 23:39:29 发布

阅读量273

点赞数

分类专栏：工具类后端文章标签： java

本文链接：https://blog.csdn.net/qq_35911118/article/details/106495065

版权

后端同时被 2 个专栏收录

100 篇文章 0 订阅

订阅专栏

工具类

36 篇文章 0 订阅

订阅专栏

//按条件过滤List filterList = list.stream().filter(user -> user.getId() > 5 && “1组”.equals(user.group)).collect(Collectors.toList());Iterator keys = map.keySet().iterator(); while(keys.hasNext()){ String key = (String)keys.next(); if(“2”.equals(key)){ System.out.println(“存在key”); }}

//判断是否存在key
map.containsKey(“opt”)
//list转map
Map<Long, User> maps = userList.stream().collect(Collectors.toMap(User::getId, Function.identity(), (key1, key2) -> key2));

if(list != null && list.size() == 0){
}

if(list != null && !list.isEmpty()){
}

//实例化ArrayList

ArrayList a1=new ArrayList();

ArrayList a2=new ArrayList();

//添加数据

a1.add(“java_01”);
a1.addAll(a2);合并一个数组
递归处理
Iterator it=a1.iterator();
while(it.hasNext())
{
String b=it.next().toString();
System.out.println(b);
}

string转数组
Arrays.asList(“B”, “E”, “D”, “C”, “A”)
// 自然顺序进行排序
TreeSet ts = new TreeSet();

    // 创建元素并添加
    // 20,18,23,22,17,24,19,18,24
    ts.add(20);
    ts.add(18);
    ts.add(23);
    ts.add(22);
    ts.add(17);
    ts.add(24);
    ts.add(19);
    ts.add(18);
    ts.add(24);

    // 遍历
    for (Integer i : ts) {
        System.out.println(i);
    }

17
18
19
20
22
23
24
TreeSet ts=new TreeSet();
//创建元素对象
Student s1=new Student(“zhangsan”,20);
Student s2=new Student(“lis”,22);
Student s3=new Student(“wangwu”,24);
Student s4=new Student(“chenliu”,26);
Student s5=new Student(“zhangsan”,22);
Student s6=new Student(“qianqi”,24);

    //将元素对象添加到集合对象中
    ts.add(s1);
    ts.add(s2);
    ts.add(s3);
    ts.add(s4);
    ts.add(s5);
    ts.add(s6);

    //遍历
    for(Student s:ts){
        System.out.println(s.getName()+"-----------"+s.getAge());
    }

public class Student implements Comparable{
private String name;
private int age;

public Student() {
    super();
    // TODO Auto-generated constructor stub
}

public Student(String name, int age) {
    super();
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

@Override
public int compareTo(Student s) {
    //return -1; //-1表示放在红黑树的左边,即逆序输出
    //return 1;  //1表示放在红黑树的右边，即顺序输出
    //return o;  //表示元素相同，仅存放第一个元素
    //主要条件 姓名的长度,如果姓名长度小的就放在左子树，否则放在右子树
    int num=this.name.length()-s.name.length();
    //姓名的长度相同，不代表内容相同,如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
    //如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。
    //如果这两个字符串相等，则结果为 0
    int num1=num==0?this.name.compareTo(s.name):num;
    //姓名的长度和内容相同，不代表年龄相同，所以还要判断年龄
    int num2=num1==0?this.age-s.age:num1;
    return num2;
}

}

lis-----------22
qianqi-----------24
wangwu-----------24
chenliu-----------26
zhangsan-----------20
zhangsan-----------22

boolean add(E e)
将指定的元素追加到此列表的末尾（可选操作）。

void add(int index, E element)
将指定的元素插入此列表中的指定位置（可选操作）。

boolean addAll(int index, Collection<? extends E> c)
将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。

void clear()
从此列表中删除所有元素（可选操作）。

boolean equals(Object o)
将指定的对象与此列表进行比较以获得相等性。

abstract E get(int index)
返回此列表中指定位置的元素。

int hashCode()
返回此列表的哈希码值。

int indexOf(Object o)
返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

Iterator iterator()
以正确的顺序返回该列表中的元素的迭代器。

int lastIndexOf(Object o)
返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

ListIterator listIterator()
返回列表中的列表迭代器（按适当的顺序）。

ListIterator listIterator(int index)
从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。

E remove(int index)
删除该列表中指定位置的元素（可选操作）。

protected void removeRange(int fromIndex, int toIndex)
从此列表中删除所有索引在 fromIndex之间的 fromIndex ，包括 toIndex ，独家。

E set(int index, E element)
用指定的元素（可选操作）替换此列表中指定位置的元素。

List subList(int fromIndex, int toIndex)
返回此列表中指定的 fromIndex （含）和 toIndex之间的视图。

public void getDatabaseList(List

databaseList) {
return databaseList;
}
public void setDatabaseList(List

databaseList) {
this.databaseList = databaseList;
}

public void setDatabaseList(String databaseList) {
List

list= JSONObject.parseArray(databaseList,Table.class);
this.databaseList = list;
}
时间戳
public void setLastDetectionTime(String lastDetectionTime){
SimpleDateFormat simple2 = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
Calendar calendar = Calendar.getInstance();
if(!StringUtil.isNullOrEmpty(lastDetectionTime)){
calendar.setTimeInMillis(Long.parseLong(lastDetectionTime));
try {
this.lastDetectionTime = simple2.parse(String.valueOf(calendar.getTimeInMillis()));
} catch (ParseException e) {
e.printStackTrace();
}
}
}

/**

单个List集合去除重复
*/
public static List removeRepeat(List list) {
Set set = new HashSet<>(list);
return new ArrayList<>(set);
}
public static void main(String[] args) throws Exception {
List users = new ArrayList<>();
for (int i = 0; i < 3; i++) {
users.add(new User(“answer” + i, new Random().nextInt(100)));
}
System.out.println(JSON.toJSONString(users));

System.out.println();

Map<String, Integer> map = users.stream().collect(Collectors.toMap(User::getName, User::getAge));
System.out.println(map);
}

[{“age”:78,“name”:“answer0”},{“age”:89,“name”:“answer1”},{“age”:72,“name”:“answer2”}]

{answer2=72, answer1=89, answer0=78}

/**
* 对list的元素按照多个属性名称排序,
* list元素的属性可以是数字（byte、short、int、long、float、double等，支持正数、负数、0）、char、String、java.util.Date
*
*
* list元素的属性名称
* @param isAsc
* true升序，false降序
*
* sortnameArr 排序的字段名称
*/
public static void sort(List list, final boolean isAsc, final String… sortnameArr) {
Collections.sort(list, new Comparator() {

        public int compare(E a, E b) {
            int ret = 0;
            try {
                for (int i = 0; i < sortnameArr.length; i++) {
                    ret = ListUtils.compareObject(sortnameArr[i], isAsc, a, b);
                    if (0 != ret) {
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return ret;
        }
    });
}

/**
 * 给list的每个属性都指定是升序还是降序
 *
 * @param list
 * @param sortnameArr  参数数组
 * @param typeArr      每个属性对应的升降序数组， true升序，false降序
 */

public static <E> void sort(List<E> list, final String[] sortnameArr, final boolean[] typeArr) {
    if (sortnameArr.length != typeArr.length) {
        throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");
    }
    Collections.sort(list, new Comparator<E>() {
        public int compare(E a, E b) {
            int ret = 0;
            try {
                for (int i = 0; i < sortnameArr.length; i++) {
                    ret = ListUtils.compareObject(sortnameArr[i], typeArr[i], a, b);
                    if (0 != ret) {
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return ret;
        }
    });
}

/**
 * 对2个对象按照指定属性名称进行排序
 *
 * @param sortname
 *            属性名称
 * @param isAsc
 *            true升序，false降序
 * @param a
 * @param b
 * @return
 * @throws Exception
 */
private static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception {
    int ret;
    Object value1 = ListUtils.forceGetFieldValue(a, sortname);
    Object value2 = ListUtils.forceGetFieldValue(b, sortname);
    String str1 = value1.toString();
    String str2 = value2.toString();
    if (value1 instanceof Number && value2 instanceof Number) {
        int maxlen = Math.max(str1.length(), str2.length());
        str1 = ListUtils.addZero2Str((Number) value1, maxlen);
        str2 = ListUtils.addZero2Str((Number) value2, maxlen);
    } else if (value1 instanceof Date && value2 instanceof Date) {
        long time1 = ((Date) value1).getTime();
        long time2 = ((Date) value2).getTime();
        int maxlen = Long.toString(Math.max(time1, time2)).length();
        str1 = ListUtils.addZero2Str(time1, maxlen);
        str2 = ListUtils.addZero2Str(time2, maxlen);
    }
    if (isAsc) {
        ret = str1.compareTo(str2);
    } else {
        ret = str2.compareTo(str1);
    }
    return ret;
}

/**
 * 给数字对象按照指定长度在左侧补0.
 *
 * 使用案例: addZero2Str(11,4) 返回 "0011", addZero2Str(-18,6)返回 "-000018"
 *
 * @param numObj
 *            数字对象
 * @param length
 *            指定的长度
 * @return
 */
public static String addZero2Str(Number numObj, int length) {
    NumberFormat nf = NumberFormat.getInstance();
    // 设置是否使用分组
    nf.setGroupingUsed(false);
    // 设置最大整数位数
    nf.setMaximumIntegerDigits(length);
    // 设置最小整数位数
    nf.setMinimumIntegerDigits(length);
    return nf.format(numObj);
}

/**
 * 获取指定对象的指定属性值（去除private,protected的限制）
 *
 * @param obj
 *            属性名称所在的对象
 * @param fieldName
 *            属性名称
 * @return
 * @throws Exception
 */
public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {
    Field field = obj.getClass().getDeclaredField(fieldName);
    Object object = null;
    boolean accessible = field.isAccessible();
    if (!accessible) {
        // 如果是private,protected修饰的属性，需要修改为可以访问的
        field.setAccessible(true);
        object = field.get(obj);
        // 还原private,protected属性的访问性质
        field.setAccessible(accessible);
        return object;
    }
    object = field.get(obj);
    return object;

}

16 /** 17 * list 中有一个为主键key
18 *
19 * @param list
20 * @param function
21 * @return 22 / 23 public static <K, V> Map<K, V> listToMap(List list, Function<V, K> function) {
24 Map<K, V> map = new HashMap<K, V>();
25 if (list == null)
26 return map;
27 for (V value : list) {
28 K k = function.apply(value);
29 map.put(k, value);
30 }
31 return map;
32 }
33
34 /* 35 * list 元素转为另一个元素的list
36 / 37 public static <F, R> List listConvert(List list, Function<F, R> function) {
38 List listN = new ArrayList();
39 if (list == null)
40 return listN;
41 for (F value : list) {
42 R r = function.apply(value);
43 if (r != null)
44 listN.add®;
45 }
46 return listN;
47 }
48
49 /* 50 * list 元素过滤另一个元素的list
51 / 52 public static List filter(List list, Function<F, Boolean> function) {
53 List listN = new ArrayList();
54 if (list == null)
55 return listN;
56 for (F value : list) {
57 Boolean r = function.apply(value);
58 if ®
59 listN.add(value);
60 }
61 return listN;
62 }
63
64 /* 65 * list 元素转为另一个元素的list并且去重,适合list数据量较小
66 / 67 public static <F, R> List listConvertAndUnique(List list, Function<F, R> function) {
68 List listN = new ArrayList();
69 if (list == null)
70 return listN;
71 for (F value : list) {
72 R r = function.apply(value);
73 if (r != null && !listN.contains®)
74 listN.add®;
75 }
76 return listN;
77 }
78
79 /* 80 * list 元素转为以seg分割的字符串
81 */ 82 public static String split(List list, String seg) {
83 StringBuilder sb = new StringBuilder();
84 for (Object value : list) {
85 sb.append(value.toString() + seg);
86 }
87 String t = sb.toString();
88 if (t.endsWith(seg)) {
89 int end = t.length() - seg.length();
90 t = t.substring(0, end);
91 }
92 return t;
93 }
94
95 public static Map<Integer, V> listToMapByHashCode(List list) {
96 Map<Integer, V> map = new HashMap<Integer, V>();
97 for (V value : list) {
98 map.put(Integer.valueOf(value.hashCode()), value);
99 }
100 return map;
101 }
102
103 public static <K, V> Map<K, V> listToMapByFunction(List list,Function<V,K> function) {
104 Map<K, V> map = new HashMap<K, V>();
105 for (V value : list) {
106 map.put(function.apply(value), value);
107 }
108 return map;
109 }
110
111 // list to ListMultimap112 public static <K, V> ListMultimap<K, V> listToListMultiMap(List list, Function<V, K> function) {
113 ListMultimap listMultimap = ArrayListMultimap.<K, V> create();
114 for (V value : list) {
115 listMultimap.put(function.apply(value), value);
116 }
117 return listMultimap;
118 }
119
120 public static List pageList(List list, int pageIndex, int pageNum) {
121 int size = list.size();
122 int fromIndex = pageIndex * pageNum;
123 if (fromIndex > size) {
124 fromIndex = size;
125 }
126 int toIndex = fromIndex + pageNum;
127 if (toIndex > size) {
128 toIndex = size;
129 return list.subList(fromIndex, toIndex);
130 }
131
132 return list.subList(fromIndex, toIndex);
133 }
134
135 public static boolean isEmpty(List list) {
136
137 return list == null || list.isEmpty();
138 }
139
140 public static List list(String s, String spe) {
141
142 ArrayList list = new ArrayList<>();
143 if (StringUtils.isBlank(s))
144 return list;
145 String[] e = s.split(spe);
146 for (String i : e) {
147 list.add(i);
148 }
149 return list;
150
151 }
152
153 public static List toList(T… a) {
154
155 if (a == null)
156 return null;
157 List l = new ArrayList<>();
158 for (T e : a) {
159 l.add(e);
160 }
161
162 return l;
163 }

//静态方法中引入service,需要通过SpringContext去获取SfService sfService = SpringContext.getApplicationContext().getBean(SfService.class);
String responseList=’’;
//String 转对象
net.sf.json.JSONObject jsonobjectNew = net.sf.json.JSONObject.fromObject(responseList)
JSONArray arrayNew =jsonobjectNew.getJSONArray(“result”);
JSONObject object =(JSONObject)arrayNew.get(i);
转对象
TF tf= JSONObject.toBean(object, TF.class);
//日志
private Logger logger = LoggerFactory.getLogger(this.getClass());
对象转对象
Ssfas sdfa = this.getMapper().map(entity,Ssfas.class);
//根据id获取集合
public static <T,K> List getKeyList(List list, String fieldName) {

List result = new ArrayList();
if(list == null || list.size() == 0){
return result;
}
Class clazz = list.get(0).getClass();
Method method = null;
try {
method = clazz.getMethod(“get” + StringUtil.upperFirstWord(fieldName));
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
Set set = new HashSet<>();

for(T t : list) {
try {
K k = (K)method.invoke(t);
if(k != null){
set.add(k);
}
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
}
for(K k : set){
result.add(k);
}
return result;
}
//集合转集合
public static <T,K> List tranferBatch(List list, Class clazz){
List tList = new ArrayList<>();