黑马程序员_JavaAPI下

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

 

        泛型概述

泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。

泛型好处：

1.将运行时期出现的问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少。

2.避免了强制转换的麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

泛型的使用：通常在集合框架中很常见，只要见到<>就要定义泛型。其实<>就是用来接收类型的。当使用集合时，将集合要存储的数据类型作为参数传递到<>中即可。

泛型类：当类中要操作的引用数据类型不确定的时候，就定义泛型类。如：class Utils<T>{}

泛型方法：因为泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

如：public <T> void show(T t){}

注：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定，可以将泛型定义在静态方法上。

如：public static <T> void method(T t){}

泛型接口：泛型定义在接口上。如：interface Inter<T>{}

泛型限定

?：通配符。可以理解为占位符。意思为不明确具体类型。

泛型限定：

? extends E：可以接收E类型或者E的子类型。E为上限。

? super E：可以接收E类型或者E的父类型。E为下限。

 

Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。

Map集合共性方法：

1.添加：

put(K key,V value);

putAll(Map<? extends K,? extends V>m);

2.删除：

clear();

remove(Object key);

3.判断：

containsValue(Object value);

containsKey(Object key);

isEmpty();

4.获取：

get(Object key);

size();

value();

entrySet();

keySet();

Map集合子类对象的特点

Map

     |------Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0版本出现，效率低。

     |------HashMap：底层是哈希表数据结构，允许使用null键null值，该集合是线程不同步的。JDK1.2版本出现，效率高。

     |------TreeMap：底层是二叉树数据结构，线程不同步。可以用于给Map集合中的键进行自然排序。

Map集合的两种取出方式：

1.keySet：将Map集合中所有的键存入到Set集合。因为Set集合具备迭代器，所以可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。

keySet取出原理：将Map集合转成Set集合，再通过迭代器取出。

示例1：

import java.util.*;
class MapDemo2
{
 public static void main(String[] args)
 {
  Map<String,String> map=new HashMap<String,String>();
  map.put("01","wanglin01");
  map.put("03","wanglin03");
  map.put("04","wanglin04");
  map.put("02","wanglin02");
  Set<String> keySet=map.keySet();
  Iterator<String> it=keySet.iterator();
  while(it.hasNext())
  {
   String key=it.next();
   String value=map.get(key);
   System.out.println("key:"+key+",value:"+value);
  }
 }
}

2.entrySet：将Map集合中的映射关系存入到了Set集合中，而这个关系的数据类型就是：Map.Entry<K,V>。

示例2：

import java.util.*;
class MapDemo3
{
 public static void main(String[] args)
 {
  Map<String,String> map=new HashMap<String,String>();
  map.put("01","wanglin01");
  map.put("03","wanglin03");
  map.put("04","wanglin04");
  map.put("02","wanglin02");
  Set<Map.Entry<String,String>> entrySet=map.entrySet();
  Iterator<Map.Entry<String,String>> it=entrySet.iterator();
  while(it.hasNext())
  {
   Map.Entry<String,String> me=it.next();
   String key=me.getKey();
   String value=me.getValue();
   System.out.println(key+"::"+value);
  }
 }
}

注：Map.Entry其实是Map接口的一个内部接口。

Map集合的应用：当数据之间存在映射关系时，就要先想到Map集合。

 

Collections：集合框架的工具类。

Collections的主要功能介绍：

1.Collections.sort(List<T> list)：用于给List集合排序。

示例1：

import java.util.*;
class CollectionsDemo
{
 public static void main(String[] args)
 {
  sortDemo();
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void sortDemo()
 {
  List<String> list=new ArrayList<String>();
  list.add("acv");
  list.add("bsd");
  list.add("kjdaaa");
  list.add("qq");
  list.add("x");
  list.add("qq");
  sop(list);
  Collections.sort(list);//按照自然顺序排序。
  Collections.sort(list,new StrLenComparator());//按照定义的比较器进行排序。
  sop(list);
 }
}
class StrLenComparator 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);
 }
}

2.Collections.max(List<T> list)：获取按自然顺序排列的最大元素。

3.Collections.binarySearch(List<T> list,element)：用折半查找的方式索引指定的元素。

4.Collections.fill(List<T> list,element)：将List集合中的所有元素替换为指定的元素。

Collections.fill(sublist,element)：将List集合中部分元素替换为指定的元素。

Collections.replaceAll(List<T> list,oldvalue,newvalue)：将List集合中的原值替换为指定的新值。

Collections.reverse(List<T> list)：将List集合反转。

示例4：

import java.util.*;
class CollectionsDemo4
{
 public static void main(String[] args)
 {
  demo(1,4);
 }
 public static void demo(int start,int end)
 {
  List<String> list=new ArrayList<String>();
  list.add("acv");
  list.add("bsd");
  list.add("kjdaaa");
  list.add("qq");
  list.add("x");
  list.add("qq");
  sop(list);
  List<String> sub=list.subList(start,end);
  Collections.fill(sub,"pp");
  sop(list);
  sop(list);
  Collections.replaceAll(list,"qq","kkkkk");
  sop(list);
  sop(list);
  Collections.reverse(list);
  sop(list);
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

5.Collections.reverseOrder()：反转自然顺序。

6.Collections.synchronizedList(List<T> list)：给List集合加锁，将其变为同步。

 

Arrays：用于操作数组的工具类，里面都是静态方法。

Arrays.asList：将数组变成List集合。

将数组变成集合的好处：可以使用集合的思想和方法来操作数组中的元素。

将数组变成集合的注意事项：

1.将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。可以使用的方法：contains();get();indexOf();subList()。

2.如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

示例：

import java.util.*;
class ArraysDemo
{
 public static void main(String[] args)
 {
  String[] arr={"abc","qq","ccccc"};
  List<String> list=Arrays.asList(arr);
  sop("contains:"+list.contains("qq"));
  //list.add("aaa");
  sop(list);
  int[] nums={2,4,54};
  List<int[]> li1=Arrays.asList(nums);
  sop(li1);
  Integer[] num={2,4,54};
  List<Integer> li2=Arrays.asList(num);
  sop(li2);

 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

 

集合变成数组：Collection接口中的toArray方法。

集合变成数组的好处：为了限定对元素的操作。主要限定对元素进行增删。

示例：

import java.util.*;
class CollectionToArray
{
 public static void main(String[] args)
 {
  ArrayList<String> al=new ArrayList<String>();
  al.add("wanglin01");
  al.add("wanglin02");
  al.add("wanglin03");
  //String[] arr=al.toArray(new String[6]);
  String[] arr=al.toArray(new String[al.size()]);//创建一个刚刚好的数组最优。
  System.out.println(Arrays.toString(arr));
 }
}

 

JDK1.5版本出现的新特性：

增强for循环（JDK1.5版本出现，可以简化书写）

格式：for(数据类型 变量名:被遍历的集合或者数组){}

增强for循环与迭代器的区别：增强for循环对集合进行遍历，只能获取元素，但是不能对集合进行操作。迭代器除了遍历，还可以进行删除集合中元素的动作。如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

注意：增强for循环有一个局限性，就是必须要有被遍历的目标。

可变参数（JDK1.5版本出现的新特性）：其实就是一种数组参数的简写形式。不用每一次都手动建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。

注意：可变参数一定要定义在参数列表最后面。

示例：

class ParamMethodDemo
{
 public static void main(String[] args)
 {
  show("wanglin",4,6,3,7,9,23);
 }
 public static void show(String s,int...arr)
 {
  sop(arr);
  sop("length:"+arr.length);
  for(int i:arr)
  {
   sop(i);
  }
  
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

静态导入：导入一个类中所有的静态成员。

示例：import java.util.*;//导入的是util包中的类。

            import static java.util.Arrays.*;//导入的是Arrays这个类中所有的静态成员。

 

System类：描述系统一些信息。类中的方法和属性都是静态的。

获取系统属性信息方法：getProperties();

示例：

import java.util.*;
class SystemDemo
{
 public static void main(String[] args)
 {
  Properties prop=System.getProperties();
  //在系统中自定义特有信息。
  System.setProperty("tangwei","i love wanglin");
  //获取指定属性信息。
  String value1=System.getProperty("os.name");
  System.out.println("value1="+value1);
  String v=System.getProperty("haha");
  System.out.println("v="+v);
  //获取所有属性信息。
  for(Object obj:prop.keySet())
  {
   String value=(String)prop.get(obj);
   System.out.println(obj+":::"+value);
  }
 }
}

 

Runtime类：该类使用了单例设计模式。

获取Runtime对象的方法：getRuntime();

示例：

class RuntimeDemo
{
 public static void main(String[] args)throws Exception
 {
  Runtime r=Runtime.getRuntime();
  //打开一个子进程。
  Process p1=r.exec("winmine.exe");
  Process p2=r.exec("notepad.exe SystemDemo.java");
  Thread.sleep(10000);
  p1.destroy();//清除子进程。
 }
}

 

Date类：描述日期。

示例：

import java.util.*;
import java.text.*;
class DateDemo
{
 public static void main(String[] args)
 {
  Date d=new Date();
  System.out.println(d);
  //将模式封装到SimpleDateFormat对象中。
  SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E HH:mm:ss");
  //调用format方法让模式格式化指定Date对象。
  String time=sdf.format(d);
  System.out.println("time="+time);
 }
}

 

Calendar类：描述日历。

示例：

import java.util.*;
class CalendarDemo
{
 public static void main(String[] args)
 {
  Calendar c=Calendar.getInstance();
  sop(c);
  c.set(2013,4,22);
  //对指定日期进行加减。
  c.add(Calendar.DAY_OF_MONTH,15);
 }

public static void sop(Object obj)
 {
  System.out.println(obj);
 }

}

 

Math类：里面都是数学方法。

示例：

import java.util.*;
class MathDemo
{
 public static void main(String[] args)
 {
  double d=Math.ceil(15.23);//ceil方法返回大于指定数据的最小整数。
  double d1=Math.floor(12.98);//floor方法返回小于指定数据的最大整数。
  long l=Math.round(19.49);//四舍五入。
  sop("d="+d);
  sop("d1="+d1);
  sop("l="+l);
  double d2=Math.pow(5,9);//5的9次幂。
  sop("d2="+d2);
  Random r=new Random();
  for(int x=0;x<10;x++)
  {
   int b=(int)(Math.random()*10+1);//随机生成1-10的数字。
   sop(b);
  }
 }
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
}

 

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------