jdk5.0的新特性---泛型
泛型:参数化类型---使用<参数化类型>的方式指定该类中方法操作的数据类型
public class Example23{
public void static main(String[] args){
ArrayList list = new ArrayList();
list.add("Feriosa");
list.add("max");
list.add(1);
for(Object obj : list){
String str = (String) obj;
}
}
}
public class Example24{
public void static main(String[] args){
ArrayList<String> list = new ArrayList<String>();
list.add("Feriosa");
list.add("max");
for(String str : list){
System.out.println(str);
}
}
}
使用“参数化类型”的方式指定该类中方法操作的数据类型
使用“参数化类型”的方式指定该类中方法操作的数据类型
使用“参数化类型”的方式指定该类中方法操作的数据类型
这样做的好处是:在编译的时候就可以解决错误,避免在程序运行时发生错误
自定义泛型:
在定义一个类的时候使用<T>申明参数类型,它的一些方法的参数类型或者返回值类型也都申明为T
class cachePool<T> {
T temp;
public void save(T temp){
this.temp = temp;
}
public T get(){
return temp;
}
}
全类中只能出现一种数据类型---T
class Example25{
public void static main(Sring[] args){
cachePool<Integer> cp = new cachePool<Integer>; //传入Integer
cp.savez(new Integer(111));
Integer i = cp.get;
}
}
Collections工具类:
根据api文档呢,有大概这几个常用的静态方法:
排序:
(这里复习一下学习循环语句时学的那几段有关排序和选择的代码)
首先明确一下这些方法是干嘛的:
选择排序+冒泡排序---》排序
二分法---》查找(如果数组是无序的,简单遍历查找就ok,如果数组是有序的,那么二分查找就比较好)
之前见到的一个排序api:Arrays.sort()---刚看了一下下一小节,arrays工具类是专门用来操作数组的,而Collections是用来操作集合的
Collections的排序:
static<T> boolean addAll(Collection<?super T> c , T...elements)---将所有指定元素添加到指定的collection中---感觉有了addAll(),不用再一个个添加了
static void reverse(List list)---反转
static void shuffle(List list)---随机排序(“洗牌”);
static void sort(List list)---按自然顺序排序
static void swap(List list , int i , int j )---将指定集合中i处元素和j处元素进行交换
public class Example26{
public void static main(String[] args){
ArrayList list = new ArrayList();
Collections.addAll(list,"feriosa","max","nux");
Collections.reverse(list);
Collections.shuffle(list);
Collections..sort(list);
Collections.swap(list,0,1);
}
}
查找和替换操作:
static int binarySearch(List list , Object key)---使用二分法搜索指定的对象在List集合中的索引,查找的List集合中的元素必须是有序的
static Object max(Collection col)
static Object min(Collection col)
static boolean replaceAll(List list, Object oldVal , Object newVal)
ok,Arrays.sort()表示数组的排序,那么逻辑思路上有两种方法---》选择法和冒泡法
其实这两种方法是路上只差一点,代码上也只差几行
选择法:依次拿数组的每一个去与它后面的每一个去比较,用大的换小的,这样一直比下去,就是左小又大
冒泡法:左边一直两两相比,留下在右边相对最大的
直接点说就是:
选择法是右边的依次和左边的比,左边留下最小的
冒泡法是总是从左边两个两个相比,然后留在右边相对最大的
代码上for(int x = 0; x < arr.length -1 ; x++)过后:
选择法:for(int y = x + 1 ; y < arr.length ; y++)
冒泡法:for(int y = 0 ; y < arr.length - 1- x ; y++)
这两句代码之后:
选择法:
if(arr[x] > arr[y]){
temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
冒泡法:
if(arr[y]>arr[y+1]){
temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
(选择法还有一个优化版本,即先记录每一轮比较完成之后最值的角标,然后最后才用swap(int[] arr , int x, int y)来实现交换
详见代码:
public static void selectSort(int[] arr){
for(int x = 0 ; x < arr.length - 1 ; x++){
arr[x] = arrx;
index = x;
for(int y = x + 1; y < arr.length ; y ++){
if(arrx > arr[y]){
arrx = arr[y];
index= y ;
}
}
if(index != x )
swap(arr,x , index);
}
}
public static void swap(int[] arr, int x , int y ){
int temp;
temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
终于搞定了这几个排序方法(两个---选择和冒泡)
还有一个binarySearch(Object[] , Object key)对应的二分法:
其实二分法超级简单(但要注意其中使用了一个while循环)
public int binarySearch(int[] arr, int x) {
int max = arr.length -1 ;
int min = 0 ;
int mid =(min + max) / 2 ;
while(min != max){
if(arr[mid] > x){
max = mid -1 ;
}else if(arr[mid]< x){
min = mid +1 ;
}else if (max < min ){
return -1;
}
mid = (max +min)/2;
}
return mid;
}
或者:
public int binarySearch(int[] arr , int x ){
int max = arr.length -1 ;
int min = 0 ;
int mid ;
while(min < max){
mid = (min +max)>>1;
if(arr[mid] > x ){
max = mid -1 ;
}else if (arr[mid] < x){
min = mid +1 ;
}else{
return mid;
}
}
return -1; //这种情况是min>= max,直接方法-1即可
}
好现在再来看Arrays类的常有静态方法:
Arrays.sort(int[] arr)---排序(类似选择法或者冒泡法)
Arrays.binarySearch(Object[] a, Object key)---查询(类似二分法)
Arrays.copyOfRange(int[] original, int from, int to)---拷贝元素(在不破环原数组的情况下)
Arrays.fill(Object[] a, Object val)---填充元素
Arrays.toString(int[] arr)---将数组转化成为字符串
这样,集合类搞定。 |
|