1. Vector 类
主要方法：
void addElement(E obj)
将指定的组件添加到此向量的末尾，且向量的大小加 1。
E elementAt(int index)
返回指定索引处的组件。
Enumeration elements()
返回此向量的组件的枚举。
Enumeration的主要方法：
boolean hasMoreElements()
测试此枚举是否包含更多的元素。
E nextElement()
如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
代码示例：
package testdemo;
import java.util.Enumeration;
import java.util.Vector;
public class ArrayListDemo {
public static void main(String[] args) {
Vector v = new Vector();
Student s1 = new Student("jimm",20);
Student s2 = new Student("linda",25);
Student s3 = new Student("dotta",28);
v.addElement(s1);
v.addElement(s2);
v.addElement(s3);
System.out.println(v);
System.out.println(v.elementAt(0));
Enumeration e = v.elements();
while(e.hasMoreElements()){
System.out.println(e.nextElement());
}
}
}
输出：
[Student name=jimm, age=20, Student name=linda, age=25, Student name=dotta, age=28]
Student name=jimm, age=20
Student name=jimm, age=20
Student name=linda, age=25
Student name=dotta, age=28
2. LinkedList类
LinkedList特有的方法：
void addFirst(E o)
将给定元素插入此列表的开头。
void addLast(E o)
将给定元素追加到此列表的结尾。(这个方法跟集合通用的方法add()的使用差不多）
E getFirst()
返回此列表的第一个元素。
E getLast()
返回此列表的最后一个元素。
E removeFirst()
移除并返回此列表的第一个元素。
E removeLast()
移除并返回此列表的最后一个元素。
代码示例：
package testdemo;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList lkd = new LinkedList();
Student s1 = new Student("jimm",20);
Student s2 = new Student("linda",25);
Student s3 = new Student("dotta",28);
lkd.addFirst(s1);
lkd.addFirst(s2);
lkd.addFirst(s3);
System.out.println(lkd);
System.out.println(lkd.getFirst());
System.out.println(lkd.getLast());
System.out.println(lkd.removeLast());
System.out.println(lkd);
}
}
输出：
[Student name=dotta, age=28, Student name=linda, age=25, Student name=jimm, age=20]
Student name=dotta, age=28
Student name=jimm, age=20
Student name=jimm, age=20
[Student name=dotta, age=28, Student name=linda, age=25]
ArrayList去重（选择排序法）
package testdemo;
import java.util.ArrayList;
import java.util.Collection;
public class RemoveDuplicateElement {
public static void main(String[] args) {
ArrayList arr0 = new ArrayList();
arr0.add("hello");
arr0.add("hello");
arr0.add("hello");
arr0.add("world");
arr0.add("world");
arr0.add("apple");
arr0.add("apple");
arr0.add("apple");
for(int i = 0; i<arr0.size();i++){
String cur = (String)arr0.get(i);
for(int j = i+1; j<arr0.size();j++){
String s = (String) arr0.get(j);
if(s.equals(cur)){
arr0.remove(s);
j--;//删除元素之后，如果不做这一步就会漏掉对下一个元素的判断
}
}
}
System.out.println(arr0);
}
}
输出：
[hello, world, apple]
创建新数组的去重方案：
public static ArrayList deleteDuplic(ArrayList arr){
ArrayList newArr = new ArrayList();
for(int i = 0; i< arr.size();i++){
String s = (String) arr.get(i);
if(!newArr.contains(s)){
newArr.add(s);
}
}
return newArr;
}
对象数组去重（姓名相同且年龄相同就算重复）：
public static ArrayList DeleteDupStu(ArrayList<Student> arr){
ArrayList<Student> newArr = new ArrayList<Student>();
for(int i = 0; i < arr.size();i++){
Student s = arr.get(i);
String name = s.getName();
int age = s.getAge();
boolean flag = true;
for(int j = 0; j <newArr.size();j++){
Student s1 = newArr.get(j);
String name1 =s1.getName();
int age1 = s1.getAge();
if(name == name1 && age == age1){
flag = false;
}
}
if(flag){
newArr.add(s);
}
}
return newArr;
}
用LinkedList实现栈（继承的方式）
package testdemo;
import java.util.LinkedList;
public class StackBasedOnLink extends LinkedList {
public StackBasedOnLink() {
super();
}
public void push(Object obj){
this.addFirst(obj);
}
public Object pop(){
return this.removeFirst();
}
}
package testdemo;
public class StackBasedOnLinkedDemo {
public static void main(String[] args) {
StackBasedOnLink sbo = new StackBasedOnLink();
sbo.push("Hello");
System.out.println(sbo);
sbo.push("Kathy");
System.out.println(sbo);
sbo.push("Do");
System.out.println(sbo);
sbo.push("you");
System.out.println(sbo);
sbo.push("like");
System.out.println(sbo);
sbo.push("Java");
System.out.println(sbo);
System.out.println("==============================");
while(!sbo.isEmpty()){
//System.out.println(std);
System.out.println(sbo.pop());
}
}
}
output:
[Hello]
[Kathy, Hello]
[Do, Kathy, Hello]
[you, Do, Kathy, Hello]
[like, you, Do, Kathy, Hello]
[Java, like, you, Do, Kathy, Hello]
==============================
Java
like
you
Do
Kathy
Hello
用LinkedList实现栈（非继承的方式）
package testdemo;
import java.util.LinkedList;
public class StackLinked{
private LinkedList lkd;
public StackLinked() {
lkd = new LinkedList();
}
public void push(Object obj){
lkd.addFirst(obj);
}
public Object pop(){
Object obj = lkd.getFirst();
lkd.removeFirst();
return obj;
}
public boolean isEmpty(){
return lkd.isEmpty();
}
@Override
public String toString() {
return ""+lkd+"";
}
}
package testdemo;
public class StackLinkedDemo {
public static void main(String[] args) {
StackLinked std = new StackLinked();
std.push("Hello");
System.out.println(std);
std.push("Kathy");
System.out.println(std);
std.push("Do");
System.out.println(std);
std.push("you");
System.out.println(std);
std.push("like");
System.out.println(std);
std.push("Java");
System.out.println(std);
System.out.println("==============================");
while(!std.isEmpty()){
//System.out.println(std);
System.out.println(std.pop());
}
}
}
output:
[Hello]
[Kathy, Hello]
[Do, Kathy, Hello]
[you, Do, Kathy, Hello]
[like, you, Do, Kathy, Hello]
[Java, like, you, Do, Kathy, Hello]
==============================
Java
like
you
Do
Kathy
Hello
3. 泛型类，泛型方法，泛型接口
泛型类，泛型方法
package testdemo;
class Calculate{
public void show(String s){
System.out.println(s);
}
public void show(Integer s){
System.out.println(s);
}
public void show(Boolean s){
System.out.println(s);
}
}
class Calculate1<T>{
private T obj;
public Calculate1(T obj) {
super();
this.obj = obj;
}
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
class Calculate2<T>{
public void show(T t ){
System.out.println(t);
}
}
public class FanXinDemo {
public static void main(String[] args) {
//一般重载
Calculate c = new Calculate();
c.show("hello");
c.show(100);
c.show(true);
System.out.println("============================================");
//泛型类
Calculate1<String> cs = new Calculate1<>("hello");
System.out.println(cs.getObj());
Calculate1<Integer> cs1 = new Calculate1<>(100);
System.out.println(cs1.getObj());
Calculate1<Boolean> cs2 = new Calculate1<>(true);
System.out.println(cs2.getObj());
System.out.println("============================================");
//泛型方法
Calculate2 ce = new Calculate2();
ce.show("hello");
ce.show(true);
ce.show(100);
}
}
泛型接口
package testdemo;
interface Cal<T> {
void show(T t);
}
class Calculator implements Cal{
@Override
public void show(Object t) {
System.out.println(t);
}
}
public class FanXinInterface {
public static void main(String[] args) {
Cal<String> c= new Calculator();
c.show("Hello");
Cal<Boolean> c1= new Calculator();
c1.show(true);
}
}
4. 泛型通配符
<?>：任意类型，如果没有明确，那么就是object类型和任意JAVA类型（如果明确写，那么左右要一致，比如：Collection ca = new ArrayList();）
<? extends E>：向下限定E以及其子类
<? super E>：向上限定E以及其父类
package testdemo;
import java.util.ArrayList;
import java.util.Collection;
public class FanxinSymbols {
public static void main(String[] args) {
Collection<Animal> ca = new ArrayList<Animal>();
Collection<?> c = new ArrayList<Animal>();
Collection<?> c1 = new ArrayList<Cat>();
Collection<?> c2 = new ArrayList<Dog>();
Collection<? extends Animal> c3 = new ArrayList<Animal>();
Collection<? extends Animal> c4 = new ArrayList<Cat>();
Collection<? extends Animal> c5 = new ArrayList<Dog>();
Collection<? super Animal> c6 = new ArrayList<Animal>();
Collection<? super Animal> c7 = new ArrayList<Object>();
}
}
class Animal{
}
class Cat extends Animal{
}
class Dog extends Animal{
}
5. 增强for循环
JDK5之后为了方便集合的遍历而出现的，可以方便的遍历集合和数组。底层是迭代器（因此要注意，涉及到集合修改时，不要使用集合修改）
格式：
for(元素类型 变量（元素）：数组或Collection集合）{
}
6. 静态导入
可以直接导入到方法级别
格式：
import static 包名…类名.方法名
7. 可变参数
如果定义方法的时候不知道该定义多少个参数，那么就可以用可变参数来接收。
格式：
修饰符 返回值类型 方法名（数据类型… 变量名）{
}
注：
1）这里的变量其实是一个数组
2）如果有一个方法有可变参数，并且有多个可变参数，那么可变参数肯定是最后一个。
案例：
键盘录入多个数据，以0结束，要求在控制台输出这个数据中的最大值。
public class ChangableParaDemo {
public static void main(String[] args) {
findMax(2,3,6,7,10);
}
public static void findMax(int...is ){
int sum = 0;
for(int x: is){
sum += x;
}
System.out.println(sum);
}
}
package practicedemo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Scanner;
public class FindMax {
public static void main(String[] args) {
//键盘录入多个数据，以0结束，要求在控制台输出这个数据中的最大值。
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字，退出请输入0");
ArrayList<Integer> c = new ArrayList<Integer>();
int a = sc.nextInt();
do{
c.add(a);
a = sc.nextInt();
}while(a!=0);
FindMax(c);
}
public static void FindMax(ArrayList<Integer> c){
if(c.size()!=0){
Integer max = c.get(0);
for(int i = 1; i <c.size();i++){
Integer cur = c.get(i);
if(cur>max){
max =cur;
}
}
System.out.println(c);
System.out.println(max);
}
}
}
注：两个Integer比较时，实际比较的是xx.intValue()
用反编译软件可以看出来。
以下是反编译的代码：
package practicedemo;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Scanner;
public class FindMax
{
public FindMax()
{
}
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字，退出请输入0");
ArrayList c = new ArrayList();
int a = sc.nextInt();
do
{
c.add(Integer.valueOf(a));
a = sc.nextInt();
} while (a != 0);
FindMax(c);
}
public static void FindMax(ArrayList c)
{
if (c.size() != 0)
{
Integer max = (Integer)c.get(0);
for (int i = 1; i < c.size(); i++)
{
Integer cur = (Integer)c.get(i);
if (cur.intValue() > max.intValue())
max = cur;
}
System.out.println(c);
System.out.println(max);
}
}
}
8. ArrayList的toString（）方法
toString（）方法存在于其继承的父类的父类AbstractCollection中。
public String toString() {
Iterator<E> it = iterator();
if (! it.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {//for (;;)跟while（true）差不多
E e = it.next();
sb.append(e == this ? "(this Collection)" : e);//如果e元素就是本类name就添加 "(this Collection)"如果不是就添加e元素
if (! it.hasNext())
return sb.append(']').toString();
sb.append(',').append(' ');
}
}
