一、泛型:简单说就是对对象类型进行限定的技术
public class GenericDemo {
public static void main(String[] args){
/*泛型作为1.5版之后的新技术,分两步使用
* 1、在类名之后用<类型参数>,这里就像函数中的普通参数一样命名即可
* 2、在生成对象和返回该对象参数时需要明确具体的类型,相当于传入实参
* 上面说的是泛型类,除此之外,泛型还可以用于类中方法和接口
*/
GenericTest<Person> gt=new GenericTest<Person>();
gt.setQ(new Person(21,"asd1"));
}
}
//泛型类
class GenericTest<Q>{
private Q q;
public Q getQ() {
return q;
}
public void setQ(Q q) {
this.q = q;
}
//静态方法不能访问类中定义的泛型,如果必须使用泛型,只能将泛型定义在方法体上
public static <W> void show1(W w){
}
}
//泛型接口
interface Inter<T>{
public void show(T t);
}
class InterImpl implements Inter<String>{
public void show(String str){
System.out.println("str="+str);
}
}
泛型示例
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator; public class GenericDemo2 {
public static void main(String[] args){
demo();
} public static void demo() {
ArrayList<String> al=new ArrayList<String>();
al.add("asd1");
al.add("asd2");
//注意
HashSet<Integer> hs=new HashSet<Integer>();
hs.add(1);
hs.add(2);
printCollection(al);
printCollection(hs);
} /*这种参数和以前的类似,就是将类型提升到Collection,
* 以便接受所有集合类型,然后用泛型规定集合中的元素类型
* ?是通配符,在类型不确定时可以指代任意类型
*/
private static void printCollection(Collection<?> coll) {
for (Iterator<?> i = coll.iterator(); i.hasNext();) {
System.out.println(i.next());
}
} //下面这种方式使用泛型方法,和上面使用?通配符类似,
//只是T可以指代具体,而?不行。如果需要对类型进行操作,就需要使用这种方式
// private static <T> void printCollection(Collection<T> coll) {
// for (Iterator<T> i = coll.iterator(); i.hasNext();) {
// System.out.println(i.next());
// }
// }
}
泛型示例2
二、Map集合:存储键值对元素
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; public class MapDemo {
public static void main(String[] args) {
MapFunctionDemo();
MapKeySetFunction();
MapEntrySetFunction();
} public static void MapFunctionDemo() {
Map<Integer,String> m=new HashMap<Integer,String>();
//设置
System.out.println(m.put(1,"asd"));
System.out.println(m.put(1,"dada"));
m.put(2,"vtr");
m.put(3,"sg");
System.out.println("m="+m);
//删除
int num=2;
System.out.println("删除掉"+num+"号元素："+m.remove(2));
System.out.println("m="+m);
//判断
System.out.println("m中存在3号元素是"+m.containsKey(3));
//获取
System.out.println("m中3号元素是"+m.get(3));
} public static void MapKeySetFunction() {
/*Map中没有迭代器,不能直接获取所有值,但是可以间接获取。使用KeySet()获取的原理
* 1、使用KeySet获取所有键所在的Set集合,！！！这些键在Set集合中的排列完全依靠Set的特点
* 2、通过Set集合的迭代器获取所有键
* 3、通过键获取对应值
*/
Map<Integer,String> m=new HashMap<Integer,String>();
m.put(3,"asd");
m.put(2,"gf");
m.put(1,"ju");
m.put(4,"cvby");
Set<Integer> s=m.keySet();
for (Iterator<Integer> i = s.iterator(); i.hasNext();) {
Integer integer =i.next();
System.out.println(integer+"..."+m.get(integer));
}
} public static void MapEntrySetFunction() {
/*第二种获取所有值的方法是使用entrySet(),返回Set集合,其中的数据类型是Map.Entry<k,v>
* Map.Entry说明Entey是Map的内部接口。
* ！！！而这个接口的方法是static的,所以可以被直接使用。
*/
Map<Integer,String> m=new HashMap<Integer,String>();
m.put(3,"asd");
m.put(2,"gf");
m.put(1,"ju");
m.put(4,"cvby");
Set<Map.Entry<Integer,String>> s=m.entrySet();
for (Iterator<Map.Entry<Integer,String>> i = s.iterator(); i.hasNext();) {
Entry<Integer, String> entry = i.next();
Integer age=entry.getKey();
String name=entry.getValue();
System.out.println(age+"..."+name);
}
}
} //内部接口和内部类的形式非常相近
interface myMap{
public static interface myEntry{
void show();
}
}
class myMapDemo implements myMap.myEntry{
@Override
public void show() {
System.out.println("实现了内部接口");
}
}
Map练习
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap; import com.lll.cn.Person; public class SubMapDemo {
public static void main(String[] args){
HashMapDemo();
TreeMapDemo();
MapTest();
} public static void HashMapDemo() {
//具有Hash特点:即唯一性
HashMap<Person,String> hm=new HashMap<Person,String>();
hm.put(new Person(21,"cio"), "河南");
hm.put(new Person(24,"asdf"), "安徽");
hm.put(new Person(22,"byee"), "黑龙江");
hm.put(new Person(23,"cf"), "黑龙江");
Set<Person> sp=hm.keySet();
for (Iterator<Person> i = sp.iterator(); i.hasNext();) {
Person p = i.next();
String address=hm.get(p);
System.out.println(p+"..."+address);
}
} private static void TreeMapDemo() {
//具有Tree特点:需要排序
TreeMap<Person,String> tm=new TreeMap<Person,String>(new ComparatorByName());
tm.put(new Person(21,"cio"), "河南");
tm.put(new Person(24,"asdf"), "安徽");
tm.put(new Person(22,"byee"), "黑龙江");
tm.put(new Person(23,"cf"), "黑龙江");
Set<Map.Entry<Person,String>> s=tm.entrySet();
for (Iterator<Map.Entry<Person,String>> i = s.iterator(); i.hasNext();) {
Entry<Person, String> entry = i.next();
Person p=entry.getKey();
String address=entry.getValue();
System.out.println(p+"..."+address);
}
} private static void MapTest() {
/*记录字串中每个字符出现的次数,思路:最后结果是字符和个数相对应,可以使用Map集合来保存
* 所以可以遍历字串,key为字符,value为个数,遇到某个字符,个数就+1
*/
String s="adsfkhukvjj";
Map<Character,Integer> m=new HashMap<Character,Integer>();
for (int i = 0; i < s.length(); i++) {
Character curr=s.charAt(i);
if(m.containsKey(curr)){
int num=m.get(curr);
m.put(curr, num+1);
}else{
m.put(curr, 1);
}
}
Set<Map.Entry<Character,Integer>> set=m.entrySet();
for (Iterator<Map.Entry<Character,Integer>> i = set.iterator(); i.hasNext();) {
Entry<Character,Integer> entry = i.next();
Character word=entry.getKey();
Integer num=entry.getValue();
System.out.println(word+"..."+num);
}
}
}
Map子类练习
三、集合框架工具类
1、Collections类用于对collection(或者是子类List/Set)或Map进行操作。例如
1、List中元素进行排序,不能使用Tree结构,因为允许重复元素,此时就可以使用Collections中的sort()进行排序。
2、binarySerach()可以对List结构进行二分查找元素,min()/max()可以获取Collection的最值
3、reverseOrder()返回一个比较器,可以对Tree结构拍好的顺序进行逆序；reverse()可以对List进行逆序操作
4、shuffle()可以对List中元素进行随机排序
5、还可以对非同步的Collection/List/Set/Map进行同步操作。synchronized类型
2、Arrays类专门用于操作数组
1、binarySerach()二分查找,sort()排序
2、copyOf()将数组复制到指定数组,长则补0/null(自动),短则截取;copyOfRange()复制数组一部分到指定数组
3、equals()比较数组是否相等
4、fill()将指定内容填充数组
重点方法:
5、asList()将数组转为List：因为数组功能太少，注意：
1、数组长度固定,所以即使转换为List,其中的增删方法也不能使用
2、由于集合中只能存放引用类型数据：如果数组中是引用类型则可以直接存入集合中;如果是基本类型则会将数组作为元素整体存入，
四、集合在1.5版本后新特性:
import java.util.ArrayList;
import java.util.List; public class JDK5new {
public static void main(String[] args){
//本部分是说明1.5版本的一些新特性
//新的for循环
newfor();
//不定参数的使用
System.out.println(somePara(1,1,2,3));
System.out.println(somePara(1,1,2,3,4));
//
} public static void newfor() {
/*1.5版之后的高级for循环主要是简化集合和数组的遍历操作,
* 参数是 类型 变量:集合名,然后就可以用变量读取数组/集合中的元素
* 注意:新的for循环目的是用于遍历简单,但是不能取代原来的for循环
*/
List<String> l=new ArrayList<String>();
l.add("asd");
l.add("fg");
l.add("rrret");
for(String i:l){
System.out.println(i);
}
} private static int somePara(int a,int... arr) {
/*Java函数中不定参数的解决方法
* 1、重载函数
* 2、使用数组接收参数
* 3、使用1.5版之后的新方法,就像该方法的参数一样,
* 优点是直接可以向函数传入多个int型数据,会自动将参数封装为数组
* ！！！注意除了这个数组之外还有其他参数时,这个参数应该放在最后
*/
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
}
JDK5new
五、其他常用基础类：、
1、System:包含一些有用的类字段和方法。它不能被实例化,其中属性和方法都是static的。
import java.util.Properties;
import java.util.Set; public class SystemDemo {
private static final String LINE_SEPARATOR=System.getProperty("line.separator");
public static void main(String[] args){
currentTime();
getProperties();
demo();
} public static void currentTime() {
//获取现在的时间毫秒值,起点是1970.1.1
long l=System.currentTimeMillis();
System.out.println(l);
} public static void getProperties() {
/*System.getProperties()获取当前系统的有关信息,返回一个Properties类型数据
* ！！！该类型是HashTable的子类,也就是键值对组合,并且键和值必须是String类型,所以不使用泛型
* ！！！注意Properties集合遍历时,使用的是自身的方法而不是继承的方法
*/
//除了可以使用系统提供的信息,还可以自己添加一些信息,是全局性的,方便使用
System.setProperty("myKey", "myValue");
Properties prop=System.getProperties();
Set<String> nameSet=prop.stringPropertyNames();
for(String name:nameSet){
String value=prop.getProperty(name);
System.out.println(name+":"+value);
}
} public static void demo() {
/*在不同系统下,有一些地方是不同的,例如换行符,windows下是\r\n,而UNIX下是\n
* 如果将文件中使用的换行符全都固定写法,则更换系统时可能出现问题
* Java在运行时会判断系统,并获取系统信息,可以用这些信息来替屏蔽掉系统,提高兼容性
*/
System.out.println("hello"+LINE_SEPARATOR+"world");
}
}
System示例
2、Runntime：典型的单例类,私有构造器且有非静态方法,
3、Math:执行数学运算的类，Random:随机数发生器类。Math中也有生成随机数的方法,但是只能是double类型,而Random类功能更强大。
4、Date类是日期类,但是其中很多方法已经过时,转而使用Calender类。DateFormat抽象类用于格式化一个日期/时间的格式,但是其中有静态工厂方法可以获取实例对象;也可以用simpleDateFormat类来进行自定义格式化。
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date; public class DateDemo {
public static void main(String[] args) throws ParseException{
demo();
FormatDemo();
parseDemo();
CalenderDemo();
} public static void demo() {
long now=System.currentTimeMillis();
Date d=new Date(now);
System.out.println(d);
} public static void FormatDemo() {
//日期/时间的格式化使用的是DateFormat类,抽象类,不能直接实例化
long now=System.currentTimeMillis();
Date d=new Date(now);
//！！！传入不同的参数对应不同的格式,解析时该格式的对象只能解析对应的字符串,见下
DateFormat df=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
String date=df.format(d);
System.out.println(date);
} public static void parseDemo() throws ParseException {
//还可以将一个表示日期时间的字符串转换为Date对象,默认只能解析以-分隔的
String str_date="2105年4月25日";
//！！！这里的参数是年/月/日分隔的时间格式,所以可以解析这种格式的 字符串
DateFormat df=DateFormat.getDateInstance(DateFormat.LONG);
Date date=df.parse(str_date);
System.out.println(date);
} public static void CalenderDemo() {
//Calender类是将日期以键值对保存,且是字符串格式
}
}
时间有关类演示