ArrayList:
ArrayList是List接口中常用的一个子实现类:
常用的遍历功能有:
1.Collection接口的获取迭代器方法 Iterator iterator()
2.List接口的获取列表迭代器方法 ListIterator listIterator()
3.ArrayList类的方法 int size()与 Object get(int index)普通for循环
package org.westos.ArrayList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class ArrayListDemo1 {
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<String>();
al.add("asdf");
al.add("qwer");
al.add("zxcv");
al.add("uiop");
//使用迭代器对集合进行遍历
Iterator<String> it=al.iterator();
while(it.hasNext()) {
String str=it.next();
System.out.println(str);
}
//使用size(),get(int index)方法
for(int i=0;i<al.size();i++)
System.out.println(al.get(i));
//使用列表迭代器对集合进行遍历
ListIterator<String> li=al.listIterator();
while(li.hasNext()) {
System.out.println(li.next());
}
}
}Vector:
Vector集合:
底层是一种可增长对象数组,查询快增删慢
线程安全,同步的,执行效率
特有功能:
public void addElement(Object obj)------->add(Object obj)
public Enumeration elements():返回此向量的枚举--->相当于:public Iterator iterator()
boolean hasMoreElements() --->boolean hasNext() ;
Object nextElement() --->Object next() ;
package org.westos.Vector;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo1 {
public static void main(String[] args) {
// 创建Vector对象
Vector<String> v = new Vector<String>();
v.addElement("qwer");// 添加元素
v.addElement("asdf");
v.addElement("zxcv");
// 遍历元素
// 返回此向量的枚举
Enumeration<String> em = v.elements();
while (em.hasMoreElements())
System.out.println(em.nextElement());
}
}
LinkedList:
LinkedList集合的特点:底层是一种链表实现,查询慢,增删快
线程不安全的,不同步,执行效率高
LinkedList集合的特有功能:
添加功能
addFirst(Object e):将指定的元素插入到列表的开头
addLast(object e):将指定的元素添加到列表末尾
获取功能:
getFirst():获取列表第一个元素
getLast():获取列表最后一个元素
删除功能
public Object removeFirst()删除并返回此列表的第一个元素。
public Object removeLast()删除并返回列表最后一个元素
package org.westos.LinkedList;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> ll=new LinkedList<String>();
ll.addFirst("asdf");//在列表首位添加元素
ll.addFirst("qwer");
ll.addFirst("zxcv");
ll.addFirst("ghjkl");
ll.addLast("bnm");//在列表末尾添加元素
System.out.println(ll.getFirst());//获取列表第一个元素
System.out.println(ll.getLast());//获取列表最后一个元素
System.out.println(ll.removeLast());//删除并返回列表最后一个元素
System.out.println(ll.removeFirst());//删除并返回列表第一个元素
System.out.println(ll.removeFirst());
}
}
自定义一个栈集合类MyStack:
创建该集合对象并调用LinkedList的特有功能:
package org.westos.LinkedList;
import java.util.LinkedList;
public class MyStack {
private LinkedList<String> ll;
public MyStack() {
ll=new LinkedList<String>();//创建LinkedList对象
}
//添加
public void addFirst(String str) {
ll.addFirst(str);
}
//获取
public String getFirst() {
return ll.getFirst();
}
//删除
public String removeFirst() {
return ll.removeFirst();
}
}
package org.westos.LinkedList;
public class MyStackDemo {
public static void main(String[] args) {
//创建MyStack对象
MyStack ms=new MyStack();
//添加元素
ms.addFirst("qwer");
ms.addFirst("asdf");
ms.addFirst("zxcv");
System.out.println(ms.getFirst());
System.out.println(ms.removeFirst());
System.out.println(ms.getFirst());
}
}
需求:给集合中添加重复的元素(字符串类型),将重复的元素从集合去除掉!
package org.westos.Test;
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
public boolean equals(Student obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
package org.westos.Test;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList<Student> list=new ArrayList<Student>();
Student s1=new Student("林俊杰",36);
Student s2=new Student("周杰伦",40);
Student s3=new Student("谢春花",25);
Student s4=new Student("莫文蔚",36);
Student s5=new Student("王菲",46);
Student s6=new Student("林俊杰",36);
Student s7=new Student("周杰伦",40);
Student s8=new Student("谢春花",25);
Student s9=new Student("莫文蔚",36);
Student s10=new Student("王菲",46);
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
list.add(s7);
list.add(s8);
list.add(s9);
list.add(s10);
//第一种方式
ArrayList<Student> list2=new ArrayList<Student>();
Iterator<Student> it=list.iterator();
while(it.hasNext()) {
if(!list2.contains(it.next()))
list2.add(it.next());
}
Iterator<Student> it2=list2.iterator();
while(it2.hasNext())
System.out.println(it2.next());
System.out.println("-------------");
//第二种方式
for(int x=0;x<list.size()-1;x++)
for(int y=x+1;y<list.size();y++) {
if(list.get(x).equals(list.get(y))) {
list.remove(y);
y--;
}
}
Iterator<Student> it3=list.iterator();
while(it3.hasNext())
System.out.println(it3.next());
}
}泛型:
泛型:将明确的集合类型的工作推迟到了创建对象或者调用方法的时候,属于一种参数化类型,可以作为参数传递.
泛型的好处:
1.将运行时期异常提前到编译时期
2.避免了强制类型转换
3.优化了设计,解决了黄色警告线问题
泛型的引出保证了程序的安全性
package org.westos.ArrayList;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class ArrayListDemo1 {
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<String>();
al.add("asdf");
al.add("qwer");
al.add("zxcv");
al.add("uiop");
//使用迭代器对集合进行遍历
Iterator<String> it=al.iterator();
while(it.hasNext()) {
String str=it.next();//避免了强制类型转换
System.out.println(str);
}
}
}把泛型定义在类上,提高了程序的安全性
解决了向下强制类型转换出现的问题:ClassCastException
package org.westos.泛型;
public class ObjectTool<T> {
private T obj;
public void set(T obj) {
this.obj=obj;
}
public T get() {
return obj;
}
}package org.westos.泛型;
public class ObjectToolDemo {
public static void main(String[] args) {
ObjectTool<String> ot=new ObjectTool<String>();
ot.set("asdd");
String str=ot.get();
//Integer i=ot.get();//创建对象时已经限定了获取值的类型为String类型
ObjectTool<Integer> ot2=new ObjectTool<Integer>();
ot2.set(new Integer(23));
Integer i=ot2.get();
}
}
可以将泛型不定义在类上,将泛型定义在类中方法上(该类没有定义成员变量的情况下)
package org.westos.泛型;
public class ObjectTool2 {
public<T> void show(T t) {
System.out.println(t);
}
}
package org.westos.泛型;
public class ObjectToolDemo2 {
public static void main(String[] args) {
ObjectTool2 ot=new ObjectTool2();
ot.show(new Integer(23));
ot.show("asdf");
}
}
将泛型定义在接口上
package org.westos.泛型;
public interface Inter<T> {
//定义一个成员方法
public abstract void show(T t1,T t2);
}
package org.westos.泛型;
/*//第一种方式,给该接口Inter的子实现类也定义泛型
public class InterImpl<T> implements Inter<T> {
@Override
public void show(T t1,T t2) {
// TODO Auto-generated method stub
System.out.println(t1.equals(t2));
}
}*/
//第二种方式,给该接口指定泛型的数据类型
public class InterImpl implements Inter<Integer> {
@Override
public void show(Integer t1, Integer t2) {
// TODO Auto-generated method stub
System.out.println(t1+t2);
}
}
package org.westos.泛型;
//第一种方式
/*public class InterImplDemo {
public static void main(String[] args) {
Inter<String> i=new InterImpl<String>();
i.show("asdf","qwer");
}
}*/
//第二种方式
public class InterImplDemo {
public static void main(String[] args) {
Inter<Integer> i=new InterImpl();
i.show(23,55);
}
}泛型高级(通配符)
<?>:代表任意Object类型,或者任意的Java类
<? extends E>:向下限定,E的子类或者E这个类型
<? super E>:向上限定,E及E的父类package org.westos.泛型;
import java.util.ArrayList;
public class GenericDemo {
public static void main(String[] args) {
ArrayList<?> list = new ArrayList<Object>();
ArrayList<?> list2 = new ArrayList<String>();
ArrayList<?> list3 = new ArrayList<Integer>();
System.out.println("------");
ArrayList<? extends Object> list4 = new ArrayList<String>();
// ArrayList<? extends String> list5=newArrayList<Integer>();//Integer不是String的子类会报错
ArrayList<? extends Object> list6 = new ArrayList<Integer>();
System.out.println("-------");
ArrayList<? super Integer> list7 = new ArrayList<Object>();
ArrayList<? super String> list8 = new ArrayList<Object>();
ArrayList<? super String> list9 = new ArrayList<String>();
}
}
118
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
