集合框架总览：
Collection 接口常用方法
//1.add()向集合中添加数据
c.add(apple01);
c.add(apple02);
c.add(apple03);
c.add(apple04);
c.add(apple05);
//2.isEmepty()检测当前集合是否为空
boolean empty = c.isEmpty();
System.out.println("is empty:"+empty);
//3.size()返回当前集合的长度
int size = c.size();
System.out.println("size:"+size);
//4.contains()检测当前集合是否包含某个指定的对象，判断的标准与具体的集合实现类有关，
//一般来说取决于集合元素的hashCode()方法和equals()方法
boolean contains = c.contains(apple03);
System.out.println("contains:"+contains);
//5.remove()删除指定元素
c.remove(apple04);
System.out.println("size:"+c.size());
//6.toArray()将当前集合转为一个Object类型的数组
Object[] array = c.toArray();
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
集合遍历方式之iterator
//1.获取Iterator迭代器
Iterator iterator = c.iterator();
//2.循环检查是否还存在“下一个”元素，使用iterator.hasNext()
//遍历开始之前，游标指向的是第一个元素“之前”的位置
//当游标指向最后一个元素时，iterator.hasNext()返回false，退出循环
while(iterator.hasNext()){
//3.在循环体中使用next()方法获取当前游标指向的元素
Object next = iterator.next();
System.out.println(next);
}
集合遍历方式之增强for循环
/*
增强for循环的格式
for(元素的类型 用来接收当前元素的变量 : 要遍历的集合){
System.out.println(指向当前元素的变量);
}
*/
for(Object o : c){
System.out.println("~"+o);
}
Set接口之HashSet
HashSet判断两个元素相等的标准：
1.hashCode()返回值相等
2.equals()方法返回true
要保证equals()方法返回true时，两个对象的hashCode()方法返回值相等
Set接口之LinkedHashSet
Set集合之TreeSet
自然排序：要求元素对象实现Comparable接口
/**
* 比较当前类的实例对象和传入的参数对象
* @return 返回整型，根据整型值判断两个对象的前后顺序
*/
@Override
public int compareTo(Object o) {
if(this == o){
return 0;
}
if(o instanceof Apple){
Apple otherApple = (Apple) o;
return appName.compareTo(otherApple.appName);
}
return 0;
}
定制排序：要求将一个Comparator接口的实现对象传入TreeSet构造器中
//TreeSet集合的定制排序：
Comparator comparator = new Comparator() {
//匿名内部类：强行创建接口或抽象类的对象时，系统会要求在创建对象的地方把抽象方法实现
@Override
public int compare(Object o1, Object o2) {
if(o1 == o2){
return 0;
}
if(o1 instanceof Banana && o2 instanceof Banana){
Banana ban01 = (Banana) o1;
Banana ban02 = (Banana) o2;
return ban01.getBanName().compareTo(ban02.getBanName());
}
return 0;
}
};
//定制排序要求将Comparator的实现对象传入TreeSet(comparator)构造器中
Set appSet = new TreeSet(comparator);
List接口
//ListIterator提供了新的方法，可以实现从后向前遍历，使用时要注意当前游标的位置
while (listIterator.hasPrevious()){
Object previous = listIterator.previous();
System.out.println(previous);
}
Arrays.asList()方法
将一组数据转换为List集合
List asList = Arrays.asList(new String[]{"apple","banana","watermelon"});
Iterator iterator = asList.iterator();
while (iterator.hasNext()) {
Object object = (Object) iterator.next();
System.out.println(object);
}
LinkedList
void addFirst(Object obj)
appList.addFirst(apple06);
void addLast(Object obj)
appList.addLast(apple07);
Object getFirst()
appList.getFirst()
Object getLast()
appList.getLast()
Object removeFirst()
appList.removeFirst();
Object removeLast()
appList.removeLast();
Vector
void addElement(Object obj)
Apple apple06 = new Apple("New Apple");
appList.addElement(apple06);添加元素
void insertElementAt(Object obj,int index)
Apple apple07 = new Apple("Insert Apple");
appList.insertElementAt(apple07, 3);在指定位置添加元素
void setElementAt(Object obj,int index)
Apple apple08 = new Apple("Replace Apple~");
appList.setElementAt(apple08, 3);将指定索引值的元素替换为新元素
void removeElement(Object obj)
appList.removeElementAt(3);删除指定位置的元素
appList.removeElement(apple04);删除指定元素，如果有多个则删除第一个
appList.removeAll(Arrays.asList(apple04,apple02));将参数集合中涉及到的全部元素都删除，即使有多个也全部删除
void removeAllElements()
appList.removeAllElements();删除集合中的全部元素
内部类：
package net.csdn.inner;
public class Outter {
private String outData = "outData";
private static String sOutData = "static out data";
//和属性、方法一样，内部类也是外部类的成员，可以使用4种权限修饰符修饰
class Inner {
//非静态内部类中不能有静态成员
/*public static void test(){
}*/
public void getData(){
//在非静态内部类的非静态资源中，外部类的非静态资源可以直接拿来用
System.out.println("~"+outData);
System.out.println("~s"+sOutData);
}
public void showMsg(){
System.out.println("I am inner");
}
}
//静态的内部类同样遵循静态资源访问的原则：资源本身可以使用类名.资源的方式访问
//静态资源内不能直接访问当前类（外部类）的非静态资源
static class StaticInner {
public static final String DATA = "static data";
public void showMsg(){
//静态内部类的非静态方法中获取外部类的非静态资源，需要创建外部类对象
System.out.println("->"+new Outter().outData);
System.out.println("s->"+sOutData);
System.out.println("I am static inner");
}
public static void getData(){
//静态内部类的静态方法中获取外部类的静态资源，直接访问
System.out.println("~s->"+sOutData);
}
}
public StaticInner getStaticInner(){
//在外部类的内部创建静态内部类的对象，new 外部类类名.内部类构造器
StaticInner staticInner = new StaticInner();
return staticInner;
}
public Inner getInner(){
//在外部类的内部创建内部类的对象，直接new
Inner inner = new Inner();
return inner;
}
public static void main(String[] args) {
Outter outter = new Outter();
Inner inner = outter.getInner();
inner.showMsg();
inner.getData();
/*StaticInner staticInner = outter.getStaticInner();
staticInner.showMsg();*/
//在静态方法或main方法中静态内部类的对象可以直接new
StaticInner staticInner = new StaticInner();
staticInner.showMsg();
StaticInner.getData();
System.out.println(StaticInner.DATA);
}
}
//这只是同一个源文件中的另一个类，和Outter没有什么关系
//只是，Outter使用public修饰后，就不能用public修饰了
//对于外部类来说，权限修饰符只有public、default
class Other {
}