1
import java.util.*; public class asList { public static void main(String args[]) { // int arr[] = {1,2,3,4,45}; // List<int[]> list = Arrays.asList(arr); // list.add("qq"); 这里不能添加,因为数组的长度是固定的 // Integer[] nums = {2,4,5,2}; // List<Integer> li = Arrays.asList(nums); //如果数组中的元素是对象,那么变成集合时,数组中的元素就直接转成集合中的元素 //如果数组中的元素是基本数据类型,那么会将该数组作为集合中的元素存在. String arr[] = {"abc","cc","kkk"}; List<String> list = Arrays.asList(arr); list.contains("cc"); } public static boolean myContains(String[] arr,String key) { for(int x=0;x<arr.length;x++) { if(arr[x].equals(key)) return true; } return false; } }
数组变集合
import java.util.*;
public class asList
{
public static void main(String args[])
{
// int arr[] = {1,2,3,4,45};
// List<int[]> list = Arrays.asList(arr);
// list.add("qq"); 这里不能添加,因为数组的长度是固定的
// Integer[] nums = {2,4,5,2};
// List<Integer> li = Arrays.asList(nums);
//如果数组中的元素是对象,那么变成集合时,数组中的元素就直接转成集合中的元素
//如果数组中的元素是基本数据类型,那么会将该数组作为集合中的元素存在.
String arr[] = {"abc","cc","kkk"};
List<String> list = Arrays.asList(arr);
list.contains("cc");
}
public static boolean myContains(String[] arr,String key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x].equals(key))
return true;
}
return false;
}
}
package pack;
import java.util.*;
public class DemoTwo {
public static void main(String args[]) {
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkk");
list.add("qq");
list.add("z");
/*
* Collections.sort(list); System.out.println(list);
*
* int a1 =Collections.binarySearch(list,"z"); //用binarySeratch都必须是有序的
*
* int a2 =Collections.binarySearch(list,"aaaa"); //这里返回-2 -(1) -1
* 返回它应该插入的地方 System.out.println(a2);
*
* int index = halfSearch(list,"cc"); //这个和binarySearch一样功能
* System.out.println(index);
*/
Collections.sort(list, new MyComparator()); // 这里
sop(list);
int index = halfSearch2(list, "aaa", new MyComparator());// 这里要和排序的方法一样
sop(index);
}
public static void sop(Object obj) {
System.out.println(obj);
}
public static int halfSearch1(List<String> list, String key) // 这里是按照字母顺序排序
{
int max, min, mid;
max = list.size() - 1;
min = 0;
while (min <= max) {
mid = (max + min) >> 1; // /2
String str = list.get(mid);
int num = str.compareTo(key);
if (num > 0)
max = mid - 1;
else if (num < 0)
min = mid + 1;
else
return mid;
}
return min;
}
public static int halfSearch2(List<String> list, String key,
Comparator<String> cmp) { // 这里是按照字母长度排序
int max, min, mid;
max = list.size() - 1;
min = 0;
while (min <= max) {
mid = (max + min) >> 1; // /2
String str = list.get(mid);
int num = cmp.compare(str, key);
if (num > 0)
max = mid - 1;
else if (num < 0)
min = mid + 1;
else
return mid;
}
return min;
}
}
class MyComparator implements Comparator<String> {
public int compare(String s1, String s2) {
if (s1.length() > s2.length())
return 1;
if (s1.length() < s2.length())
return -1;
return s1.compareTo(s2);
}
}
package pack;
import java.util.*;
public class DemoTwo
{
public static void main(String args[])
{
//TreeSet<String> ts= new TreeSet<String>(new MyComparator());
//TreeSet<String> ts= new TreeSet<String>(Collections.reverseOrder());
//将已知比较器顺序逆转
TreeSet<String> ts= new TreeSet<String>(Collections.reverseOrder(new MyComparator()));
ts.add("dsfdsf");
ts.add("fssd");
ts.add("wwsdf");
ts.add("ysfd");
ts.add("zdfdf");
System.out.println(ts);
}
}
class MyComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
return s2.compareTo(s1);
}
}
集合变数组
package pack;
import java.util.*;
public class DemoTwo
{
public static void main(String args[])
{
/*
1当指定类型的数组到底要定义多长呢?
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组,长度为集合的size.
2,最好创建一个刚刚好的数组最好
*/
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
// String arr[] = al.toArray(new String[5]);//这里是创建数组的对象和大小和类型
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
// 为什么集合变数组 为了限定对元素的操作.
List<String> list = new ArrayList<String>();
Collections.replaceAll(list,"aaa","litiepeng");//替换list集合里面的元素替
Collections.reverse(list);//倒转
Collections.fill(list,"pp"); //意思就是用东西替换集合里的所有元素
String max = Collections.max(list); //找出最大的来
String max = Collections.max(list,new MyComparator()); //找出最长的来
Collections.sort(list); //排序
Collections.sort(list,new MyComparator()); //按照自己的构造器排序
Collections.binarySearch(list,key);
Collections.binarySearch(list,key,new mycomparator());
Collections.fill(List<String> list,T obj); //把集合全部换成别的
Collections.max(Collection c)
Collections.max(Collection c,new myComparator())
同理min
Collections.mix(Collection c)
Collections.mix(Collection c,new myComparator())
Collections.replaceAll(list,orld,new)用新的换旧的
Collections.reverse(List list);
Collections.reverseOrder() //返回一个构造器
Collections.reverseOrder(new myComparator())
Collections.swap(List<?> list, int i, int j)
Collections.synchronizedList(list)
Collections.shuffle(List<?> list) 使用默认随机源对指定列表进行置换。 意思就是把集合里面的东西随机再次排列一遍
Arrays.asList(数组) //数组变集合
Arrays.binarySearch()
数组变集合时
// int arr[] = {1,2,3,4,45};
// List<int[]> list = Arrays.asList(arr);
// list.add("qq"); 这里不能添加,因为数组的长度是固定的
// Integer[] nums = {2,4,5,2};
// List<Integer> li = Arrays.asList(nums);
//如果数组中的元素是对象,那么变成集合时,数组中的元素就直接转成集合中的元素
//如果数组中的元素是基本数据类型,那么会将该数组作为集合中的元素存在.
集合变数组
// String arr[] = al.toArray(new String[5]);//这里是创建数组的对象和大小和类型
String[] arr = al.toArray(new String[al.size()]);
/*
1当指定类型的数组到底要定义多长呢?
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组,长度为集合的size.
2,最好创建一个刚刚好的数组最好
*/
/* 为什么集合变数组
为了限定对元素的操作.
String[] arr = {"abc","cc","kkkk"};
List<String> list = Arrays.asList(arr);
list.contains("cc");
list.add("qq");//异常 UnsupportedOperationException,因为数组的长度是固定.
注意:将数组变成集合,不可以使用集合的增删方法.
其他的都可以用
contains.get.indexOf(),subList()
如果你增删,会发生异常
把数组变成list集合后有什么好处?
答:当要判断数组中是否存在某个元素.可以把数组变成list
可以使用集合的思想和方法来操作数组中的元素.
高级for循环
格式:
for(数组类型 变量名:被遍历的集合(Collection)或者数组)
{
}
对集合进行遍历.
只能获取集合元素,但是不能对集合进行操作.
迭代器除了遍历,还可以进行remove集合中元素的动作.
如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作.
传统for和高级for有什么区别呢?
高级for有一个局限性,必须有被遍历的目标.
可变参数:
在使用时注意:可变参数一定要定义在参数列表的最后面
可变参数:其实就是上一种数组参数的简写形式.
不用每一次都手动的建立数组对象.
只要将要操作的元素作为参数传递即可
隐式将这些参数封装成了数组
public static void show(String str,int... arr)