List<String>list=new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
List<String>list1=new ArrayList<String>();
list1.add("a");
list1.add("b");
list1.add("d");
list1.add("e");
//两个集合的交集
// list.retainAll(list1);
//两个集合的并集
// list.addAll(list1);
//两个集合的差集
list.removeAll(list1);
System.out.println(list);
--------------------------------------------------------------------------------------------------------------------
//字符去重
char[] list = { 'a', 'a', 'c', '1', '2', 'd', 'e', 'f', 'h', 'k', 'd', 'a', 'n', '1' };
List<Character> list2 = new ArrayList<Character>();// 必须如此声明，不能List<Character>list2=null，这样声明，会报空指针异常
for (int i = 0; i < list.length; i++) {
if (!list2.contains(list[i])) {// 如果不包含该值 添加到该集合
list2.add(list[i]);}
}
System.out.println(list2);
//去重排序
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(4);
list.add(6);
list.add(5);
list.add(1);
list.add(2);
Set<Integer> set = new HashSet<>();
for (int i = 0; i < list.size(); i++) {
set.add(list.get(i));
}
Integer[] arr = (Integer[]) set.toArray(new Integer[set.size()]);
int temp;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] < arr[j + 1]) { //< 降序 >升序
temp = arr[j];
arr[j ] = arr[j+1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
//循环list嵌套map
List<Map<String, String>> list = new ArrayList<Map<String, String>>();
Map<String, String> map = new HashMap<String, String>();
map.put("a", "xiaowang");
map.put("b", "xiaoli");
map.put("d", "xiaozhou");
list.add(map);
//Map<String, String>相当于list<String>的String
for (Map<String, String> m : list) {
//嵌套一层for 循环map
for (String k : m.keySet()) {
System.out.println(k);
System.out.println(k + "=" + m.get(k));
}
}
////////////////////////////////////////
List<String> list2 = new ArrayList<String>();
list2.add("a");
list2.add("b");
list2.add("c");
for (String s : list2) {
System.out.println(s);
}
System.out.println("******************************");
for (int i = 0; i < list2.size(); i++) {
System.out.println(list2.get(i));
}
}
数组转List
String[] staffs = new String[]{"Tom", "Bob", "Jane"};
List staffsList = Arrays.asList(staffs);
需要注意的是， Arrays.asList() 返回一个受指定数组决定的固定大小的列表。所以不能做 add 、 remove 等操作，否则会报错
如果想再做增删操作呢？将数组中的元素一个一个添加到列表，这样列表的长度就不固定了，可以进行增删操作
List staffsList = new ArrayList<String>();
for(String temp: staffs){
staffsList.add(temp);
}
staffsList.add("Mary"); // ok
staffsList.remove(0); // ok
数组转Set
String[] staffs = new String[]{"Tom", "Bob", "Jane"};
Set<String> staffsSet = new HashSet<>(Arrays.asList(staffs));
staffsSet.add("Mary"); // ok
staffsSet.remove("Tom"); // ok
List转数组
String[] staffs = new String[]{"Tom", "Bob", "Jane"};
List staffsList = Arrays.asList(staffs);
Object[] result = staffsList.toArray();
List转Set
String[] staffs = new String[]{"Tom", "Bob", "Jane"};
List staffsList = Arrays.asList(staffs);
Set result = new HashSet(staffsList);
Set转数组
String[] staffs = new String[]{"Tom", "Bob", "Jane"};
Set<String> staffsSet = new HashSet<>(Arrays.asList(staffs));
Object[] result = staffsSet.toArray();
Set转List
String[] staffs = new String[]{"Tom", "Bob", "Jane"};
Set<String> staffsSet = new HashSet<>(Arrays.asList(staffs));
List<String> result = new ArrayList<>(staffsSet);
String[] array = {"m", "a", "b", "c", "c", "d", "e", "e", "e", "a" };
List<String> result = new ArrayList<>();
for (int i = 0; i < array.length; i++) {
boolean flag = false ;
for (int j = 0; j < result.size(); j++) {
if (array[i].equals(result.get(j))) {
flag = true;
break;
}
}
if (!flag) {
result.add(array[i]);
}
}
String[] arrayResult = (String[]) result.toArray(new String[result.size()]);
Arrays.sort(arrayResult);
for (String vo : arrayResult) {
System.out.println(vo);
}
取数组最大或list最大值，基本是一样的
int arr[] = {7, 5, 4, 1, 6, 9, 5, 6 };
List<Integer> list = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
if(!list.contains(arr[i])) {
list.add(arr[i]);
}
}
//System.out.println(list);
int max=list.get(0);//假设第一个最大
for (int i = 0; i <list.size(); i++) {
if(list.get(i)>max) {
max=list.get(i);
}
}
System.out.println(max);
判断数组是否有重复的元素，如果有请找出
int array[] = { 44, 66, 88, 44 };
// 声明一个空的集合
List<Integer> list = new ArrayList<>();
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < array.length; i++) {
if (!list.contains(array[i])) {
list.add(array[i]);
} else {
set.add(array[i]);
}
}
// 判断长度
if (array.length != list.size()) {
System.out.println("有重复的元素");
} else {
System.out.println("没有重复的元素");
}
System.out.println(list);
System.out.println(set);
}
/**
*批量增加海量数据
*<!-- 批量增加 -->
<insert id="insertBatch" parameterType="map">
<selectKey keyProperty="id" order="AFTER" resultType="int">
select last_insert_id()
</selectKey>
insert into mytest
(name,birthday)
values
<foreach collection="personList" item="person" separator=",">
(#{person.name},#{person.birthday})
</foreach>
</insert>
*/
@Test
public void testInsertBatch() throws Exception {
List<TestTb> list=new ArrayList<>();
Map<String, Object> map=new HashMap<String, Object>();
for (int i = 0; i < 1000008; i++) {
TestTb testTb=new TestTb();
testTb.setName("贝贝"+i);
testTb.setBirthday(new Date());
list.add(testTb);
if(i%500==0){
map.put("personList", list);
testTbService.insertBatch(map);
//清空，之后继续添加
list.clear();
}
}
//零头的添加
map.put("personList", list);
testTbService.insertBatch(map);}
/***批量删除海量数据
*<!-- 批量删除 item="idd" 变量自定的，怎么定义的，就怎么取 #{idd} -->
<delete id="deleteBatch" parameterType="map">
delete from mytest where id in
<foreach collection="ids" item="idd" open="(" close=")" separator=",">
#{idd}
</foreach>
</delete>
*/
@Test
public void testDeteleBatch() throws Exception {
List<Integer> list=new ArrayList<Integer>();
Map<String, Object> map=new HashMap<String, Object>();
for (int i = 100330; i <= 2000337; i++) {
list.add(i);
if(i%500==0){
map.put("ids", list);
testTbService.deleteBatch(map);;
//清空，之后继续删除
list.clear();
}
}
//零头的删除
map.put("ids", list);
testTbService.deleteBatch(map);
}
}