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 +ｍin)/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)---将数组转化成为字符串
这样，集合类搞定。 |
|
收藏
淘帖
踩
