目录
泛型
泛型机制
泛型机制是一种把数据类型的明确工作，推迟到创建对象或调用方法的时候再执行的一种机制。
例如，在创建集合对象时，如果忽视泛型，直接写上 Object obj = new ArrayList(); 那么此时还是没有明确集合的数据类型，所以创建的集合中是可以存放任何数据类型的元素的（当然集合中只能存放对象）。如果此时存入了一个字符串对象"hello"，我们要使用字符串类型的特有方法，就必须要进行向下转型，如下：
import java.util.ArrayList;
public class Test4 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new java.lang.String("hello"));
Object o = list.get(0);
String s= (String) o;
int i = s.compareTo("hellow");
System.out.println(i);
}
}但是，如果我们直接在创建集合的时候明确了数据类型，那么集合的元素的数据类型，就是你明确的这个数据类型。就会少许多麻烦。如下
import java.util.ArrayList;
public class Test5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add(new String("hello"));
int i = list.get(0).compareTo("hellow");
System.out.println(i);
}
}泛型的特点
1）只在编译期有效，在运行期就擦除了；
2）提高了代码的扩展性；
3）泛型是在JDK1.5之后引入的。
4）避免了强制类型转换；
5）优化了程序设计，解决了黄色警告线。
泛型类
泛型定义在类上，此类成为泛型类，如
public class MyDemo<X> {
public void myDemo(){}
}泛型接口
泛型也可以定义在接口上，此接口称为泛型接口
public interface MyInterface<X, Y> {
void show(X x, Y y);
}在一个实现类实现这个接口时，就可以明确泛型的具体类型。
public class Test implements Inter<String,Integer>{
@Override
public void show(String s, Integer integer) {
;
}
}当然也可以不明确具体的数据类型来实现接口
public class Test2<X, Y> implements Inter<X,Y> {
@Override
public void show(X x, Y y) {
}
}ArrayList
ArrayList存储字符串并遍历
import java.util.ArrayList;
import java.util.Iterator;
public class Test4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("Alice");
list.add("Helen");
list.add("Jack");
//迭代器遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
System.out.println(s);
}
//普通for遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}ArrayList存储自定义对象并遍历
import java.util.ArrayList;
import java.util.Iterator;
public class Test3 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("Alice",18));
list.add(new Student("Jack",19));
list.add(new Student("Helen",18));
//迭代器遍历
Iterator<Student> iterator = list.iterator();
while (iterator.hasNext()) {
Student next = iterator.next();
System.out.println(next);
}
//普通for遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}Vector的特有功能
public void addElement(E obj) //将指定的元素添加到此向量的末尾，将其大小增加 1。如果向量的大小比容量大，则增大其容量。 public E elementAt(int index) //返回指定索引处的元素。 public Enumeration elements() //返回此向量的组件的枚举。返回的 Enumeration 对象将生成此向量中的所有项。生成的第一项为索引 0 处的项，然后是索引 1 处的项，依此类推。 E firstElement() //返回此向量的第一个组件（位于索引 0) 处的项） E lastElement() //返回此向量的最后一个组件。 void insertElementAt(E obj, int index) //将指定对象作为此向量中的组件插入到指定的 index 处。
Vector的特有功能的实现
import java.util.Vector;
public class Test5 {
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
vector.add("Alice");
vector.add("Helen");
//将元素添加到集合的末尾
vector.addElement("Jack");
//返回索引处的元素
String s = vector.elementAt(0);
//返回第一个元素
String firstElement = vector.firstElement();
//返回最后一个元素
String lastElement = vector.lastElement();
//将元素插入到指定索引处
vector.insertElementAt("Insert",1);
}
}LinkedList的特有功能
//将指定元素插入到此列表的开头 public void addFirst(E e) //将指定元素添加到此列表的结尾。 public void addLast(E e) //返回此列表的第一个元素。 public E getFirst() //返回此列表的最后一个元素。 public E getLast() //移除并返回此列表的第一个元素。 public E removeFirst() //移除并返回此列表的最后一个元素。 public E removeLast()
LinkedList的特有功能的实现
import java.util.LinkedList;
public class Test6 {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
//将指定元素插入到此列表的开头
list.addFirst("addFirst");
//将指定元素添加到此列表的结尾。
list.addLast("addLast");
//返回此列表的第一个元素。
String first = list.getFirst();
//返回此列表的最后一个元素。
String last = list.getLast();
//移除并返回此列表的第一个元素。
String removeFirst = list.removeFirst();
//移除并返回此列表的最后一个元素。
String removeLast = list.removeLast();
}
}去除ArrayList中重复字符串元素方式
需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
思路一：创建新集合方式
import java.util.ArrayList;
import java.util.Iterator;
public class Test7 {
public static void main(String[] args) {
//ArrayList去除集合中字符串的重复值(字符串的内容相同)
//创建新集合的方式
ArrayList<Integer> list = new ArrayList<>();
list.add(200);
list.add(400);
list.add(1);
list.add(1);
list.add(900);
list.add(200);
list.add(600);
list.add(2);
list.add(200);
list.add(2);
list.add(50);
ArrayList<Integer> newList = new ArrayList<>();
newList.add(list.get(0));
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
Integer next = iterator.next();
if(!newList.contains(next)){
newList.add(next);
}
}
System.out.println(newList);
}
}思路二：不创建新的集合，在原集合中进行操作
import java.util.ArrayList;
public class Test6 {
public static void main(String[] args) {
//ArrayList去除集合中字符串的重复值(字符串的内容相同)
ArrayList<Integer> list = new ArrayList<>();
list.add(200);
list.add(400);
list.add(1);
list.add(1);
list.add(900);
list.add(200);
list.add(600);
list.add(2);
list.add(200);
list.add(2);
list.add(50);
for (int i = 0; i < list.size()-1; i++) {
for (int j = i+1; j < list.size(); j++) {
if(list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
}
}
System.out.println(list);
}
}思路三：使用LinkedHashSet集合
import java.util.ArrayList;
import java.util.LinkedHashSet;
public class Test5 {
public static void main(String[] args) {
//ArrayList去除集合中字符串的重复值(字符串的内容相同)
//使用LinkedHashSet集合，
ArrayList<Integer> list = new ArrayList<>();
list.add(200);
list.add(400);
list.add(1);
list.add(1);
list.add(900);
list.add(200);
list.add(600);
list.add(2);
list.add(200);
list.add(2);
list.add(50);
//使用有参构造创建LinkedHashSet对象，并且将list当做参数传入
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(list);
System.out.println(linkedHashSet);
}
}