本文主要介绍:
1.集合框架
2.泛型
3.内部类
1.集合框架
集合是一个对象容器,用来存储其它的多个对象。
他们的关系如下图:
List和Set是Collection的子类
Collection:存储的元素好似Object对象
方法:
add(Object o):把对象加入集合。
addAll(Collection c):把c中所有对象放入集合。
clear():清空集合。
Contains(Object s):判断对象是否存在。
List:
接口
特点:元素有顺序,可以重复。
实现类:
1.ArrayList 用数组实现 查询快 增删慢
2.vector 用数组实现 重量级 线程安全
3.LinkedList 用链表实现 查询慢 增删快
利用LinKedList可以定义栈
eg:
class stack
{
private LinkedList
遍历方式:
1.for循环
eg:
Studen one1 = new Studen(20, "小明");
Studen one2 = new Studen(50, "小白");
Studen one3 = new Studen(40, "小红");
java.util.List list = new ArrayList<>();
list.add(one1);
list.add(one2);
list.add(one3);
for (int i = 0; i
2.迭代器遍历
eg:
Studen one1 = new Studen(20, "小明");
Studen one2 = new Studen(50, "小白");
Studen one3 = new Studen(40, "小红");
java.util.List list = new ArrayList<>();
list.add(one1);
list.add(one2);
list.add(one3);
Iterator iterator = list.iterator();
while(iterator.hasNext())
{
Studen s = iterator.next();
System.out.println("age"+s.age+"name"+s.name);
}
3.for-each
eg:
Studen one1 = new Studen(20, "小明");
Studen one2 = new Studen(50, "小白");
Studen one3 = new Studen(40, "小红");
java.util.List list = new ArrayList<>();
list.add(one1);
list.add(one2);
list.add(one3);
for (Studen studen : list)
{
System.out.println("age"+studen.age+"name"+studen.name);
}
Set
是接口
特点:元素无顺序,内容不重复。
方法:全部继承自Collection接口
实现类:
1.HashSet
HashSet把自定义对象放入HashSet,元素加入HashSet中,会先比较哈希码,如果哈希码相同,再调用equals()看是否为同一元素,为保证元素不重复。需要进行以下两步:
1.覆盖hashCode(),保证相同对象返回相同的int,尽量保证不同对象返回不同的哈希码。
2.覆盖equals(),保证相同对象返回true。
eg:
class Studen implements Comparable
{
int age;
String name;
Studen()
{
}
Studen(int age,String name)
{
this.age = age;
this.name = name;
}
@Override
public int compareTo(Studen arg0)
{
// TODO Auto-generated method stub
if (this.age>arg0.age)
{
return -1;
}
else if (this.age
2.TreeSet
继承与SortedSet,SortedSet是Set的子接口。
TreeSet实现了SortedSet,对元素自动排序,要求元素必须实现Comparable接口。
Map
特点:元素由键值组成,key是唯一,不可重复
方法:
put(Object k,Object v):把K-V这个键值放入Map中,如果k以及存在,那么新值就会替换旧值。
get(Object k):返回Map中对应的Value。
remove(Object k):删除Map中k对应的Value。
size():返回键值对应的数量。
ContainsKey(Object k):判断k这个键是否存在。
ContainsValue(Object v):判断v这个值是否存在。
实现类:
1.HashMap 允许null作为key或value
2.HashTable 不允许null作为key或者value
3.Properties HashTable的子类,key和value都是String 一般用于配置文件的读取
4.TryMap 实现了SortedMap(Map的子接口),自动对键排序。
遍历:
1.值遍历
values():返回Map中所有值的集合
eg:
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
for(Integer value:map.values())
{
System.out.println("值是:+"+value);
}
2.键遍历
keySet():返回Map中所有键的集合 Set
eg:
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
for(String keys:map.keySet())
{
System.out.println("值是:+"+map.get(keys));
}
3.键值对遍历
entrySet():返回Map中所有的键值对的集合
Map.Entry对象封装了一个key和一个value。
eg:
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
for(Map.Entry entry:map.entrySet())
{
System.out.println("键是: "+entry.getKey()+"值是: "+entry.getValue());
}
4.迭代器遍历
eg:
Map map = new HashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("three", 3);
Iterator> iterator2 = map.entrySet().iterator();
while (iterator2.hasNext())
{
Entry entry = iterator2.next();
System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
2.泛型
我们首先定义一个简单的Box类:
public class Box {
private String object;
public void set(String object) { this.object = object; }
public String get() { return object; }
}
这是最常见的做法,这样做的一个坏处是Box里面现在只能装入String类型的元素,今后如果我们需要装入Integer等其他类型的元素,还必须要另外重写一个Box,代码得不到复用,使用泛型可以很好的解决这个问题。
public class Box {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
这样我们的Box类便可以得到复用,我们可以将T替换成任何我们想要的类型:
Box integerBox = new Box();
Box doubleBox = new Box();
Box stringBox = new Box();
通配符:
首先看下面的代码:
public void boxTest(Box n) { /* ... */ }
那么现在Box
public void boxTest(Box n) { /* ... */ }
该成以上就好了
? 表示任何类型
?extends Number Number类或它的子类
? super Number Number类或它的任何父类
?extends Comparable 任何实现Comparable接口的类
3.内部类
既类中定义类,分为成员内部类,静态内部类,局部内部类,和匿名内部类
1.成员内部类
可以访问外部类的私有变量
创建成员内部类对象,必须先创建外部类对象,再通过外部类对象.new构造内部类对象
成员内部类不能有静态成员
外部类名.this 指向外部类当前对象
2.静态内部类
只能访问外部静态成员
创建静态内部类对象,不需要创建外部对象
定义在代码块、方法体内、作用域(使用花括号“{}”括起来的一段代码)内的类叫局部内部类。
3.局部内部类
局部内部类只能在代码代码块、方法体内和作用域中使用(如创建对象和使用类对象等)
局部内部类访问作用域内的局部变量,该局部变量需要使用final修饰。
可以使用abstract修饰,声明为抽象类
4.匿名内部类
只能使用一次,创建实例之后,类定义会立即消失(想要多次使用就要用到反射的知识了)
必须继承一个类(抽象的、非抽象的都可以)或者实现一个接口。如果父类(或者父接口)是抽象类,则匿名内部类必须实现其所有抽象方法。
不能是抽象类,因为匿名内部类在定义之后,会立即创建一个实例。
不能定义构造方法,匿名内部类没有类名,无法定义构造方法,但是,匿名内部类拥有与父类相同的所有构造方法。
可以定义代码块,用于实例的初始化,但是不能定义静态代码块。
可以定义新的方法和属性(不能使用static修饰),但是无法显式的通过“实例名.方法名(参数)”的形式调用,因为使用new创建的是“上转型对象”(即父类声明指向子类对象)。
是局部内部类,所以要符合局部内部类的要求。