一、ArrayList类
1.1、ArrayList类概述
ArrayList类概述
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
1.2、成员方法
与之前提到List类大致相同。
1.3、练习
①存储字符串并遍历：
public static void main(String[] args) {
ArrayList arr = new ArrayList();
arr.add("hello");
arr.add("world");
arr.add("java");
Iterator iterator = arr.iterator();
while(iterator.hasNext()){
String s = (String)iterator.next();
System.out.println(s);
}
for(int i=0;i<arr.size();i++){
System.out.println(arr.get(i));
}
}
②存储自定义对象并遍历
public static void main(String[] args) {
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",30);
Student s3 = new Student("王五",18);
ArrayList arr = new ArrayList();
arr.add(s1);
arr.add(s2);
arr.add(s3);
Iterator it = arr.iterator();
while(it.hasNext()){
Student s = (Student)it.next();
System.out.println(s);
}
for(int i=0;i<arr.size();i++){
Student s = (Student)arr.get(i);
System.out.println(s);
}
}
二、Vector类
2.1、Vector类概述
底层数据结构是数组，查询快，增删慢
线程安全，效率低
2.2、Vector类特有功能
public void addElement(E obj) //相当于add
public E elementAt(int index) //相当于get
public Enumeration elements() //相当于迭代器，iterator
public static void main(String[] args) {
Vector ve = new Vector();
ve.addElement("hello");
ve.addElement("world");
ve.addElement("java");
for (int i = 0; i < ve.size(); i++) {
String s = (String) ve.elementAt(i);
System.out.println(s);
}
System.out.println("=================");
Enumeration elements = ve.elements();
while(elements.hasMoreElements()){
String s=(String)elements.nextElement();
System.out.println(s);
}
}
2.3、练习
存储自定义对象并遍历：
public static void main(String[] args) {
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",24);
Student s3= new Student("王五",25);
Vector v = new Vector();
v.addElement(s1);
v.addElement(s2);
v.addElement(s3);
Enumeration elements = v.elements();
while(elements.hasMoreElements()){
Student s =(Student)elements.nextElement();
System.out.println(s);
}
}
三、LinkedList类
3.1、LinkedList类概述
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
3.2、LinkedList类特有功能
public void addFirst(E e)
addLast(E e)
public E getFirst()
getLast()
public E removeFirst()
public E removeLast()
public static void main(String[] args) {
LinkedList lk = new LinkedList();
lk.add("hello");
lk.add("world");
lk.add("java");
lk.addFirst("123");
lk.addLast("456");
System.out.println(lk);
System.out.println("==========");
Object first = lk.getFirst();
String s1=(String)first;
Object last = lk.getLast();
String s2=(String)last;
System.out.println(s1+"==="+s2);
System.out.println("===========");
lk.removeFirst();
lk.removeLast();
System.out.println(lk);
}
3.3、练习
①存储字符串并遍历
public static void main(String[] args) {
LinkedList lk = new LinkedList();
lk.add("hello");
lk.add("world");
lk.add("java");
Iterator it = lk.iterator();
while(it.hasNext()){
String s=(String)it.next();
System.out.println(s);
}
}
②存储自定义对象并遍历
public static void main(String[] args) {
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",24);
Student s3 = new Student("王五",26);
LinkedList linkedList = new LinkedList();
linkedList.add(s1);
linkedList.add(s2);
linkedList.add(s3);
Iterator it = linkedList.iterator();
while(it.hasNext()){
Student s=(Student)it.next();
System.out.println(s);
}
}
③去除集合中字符串的重复值(字符串的内容相同)
方式一：
public static void main(String[] args) {
ArrayList arr1 = new ArrayList();
arr1.add("hello");
arr1.add("hello");
arr1.add("hello");
arr1.add("world");
arr1.add("world");
arr1.add("java");
ArrayList arr2 = new ArrayList();
Iterator it = arr1.iterator();
while(it.hasNext()){
String s=(String)it.next();
if(!arr2.contains(s)){
arr2.add(s);
}
}
System.out.println(arr2);
}
方式二：
public static void main(String[] args) {
ArrayList arr = new ArrayList();
arr.add("hello");
arr.add("hello");
arr.add("hello");
arr.add("world");
arr.add("world");
arr.add("java");
for(int i=0;i< arr.size()-1;i++){
for(int j=i+1;j<arr.size();j++){
if(arr.get(i).equals(arr.get(j))){
arr.remove(j);
j--;
}
}
}
System.out.println(arr);
}
④去除集合中自定义对象的重复值
public static void main(String[] args) {
Student s1 = new Student("张三",23);
Student s2 = new Student("李四",30);
Student s3 = new Student("王五",18);
Student s4 = new Student("张三",23);
Student s5 = new Student("李四",30);
ArrayList arrayList1 = new ArrayList();
arrayList1.add(s1);
arrayList1.add(s2);
arrayList1.add(s3);
arrayList1.add(s4);
arrayList1.add(s5);
ArrayList arrayList2 = new ArrayList();
Iterator it = arrayList1.iterator();
while(it.hasNext()){
Student s=(Student)it.next();
if(!arrayList2.contains(s)){
arrayList2.add(s);
}
}
System.out.println(arrayList2);
}
⑤请用LinkedList模拟栈数据结构的集合，并测试
public class MyStack {
private LinkedList link;
public MyStack(){
link=new LinkedList();
}
public void add(Object obj){
link.addFirst(obj);
}
public Object get(){
return link.removeFirst();
}
public boolean isEmpty(){
return link.isEmpty();
}
}
public class MyStackTest {
public static void main(String[] args) {
MyStack ms = new MyStack();
ms.add("hello");
ms.add("world");
ms.add("java");
while(!ms.isEmpty()){
System.out.println(ms.get());
}
}
}
四、泛型
4.1、泛型由来
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
例如：
public static void main(String[] args) {
ArrayList arr = new ArrayList();
arr.add("hello");
arr.add("world");
arr.add("java");
arr.add(new Integer(100));
Iterator it = arr.iterator();
while(it.hasNext()){
String s=(String)it.next();//ClassCastException
System.out.println(s);
}
}
4.2、泛型应用
泛型类
把泛型定义在类上
格式:public class 类名<泛型类型1,…>
注意:泛型类型必须是引用类型
泛型方法
把泛型定义在方法上
格式:public <泛型类型> 返回类型 方法名(泛型类型 .)
泛型接口
把泛型定义在接口上
格式:public interface 接口名<泛型类型1…>
4.3、泛型通配符
泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E
向下限定，E及其子类
? super E
向上限定，E及其父类
五、增强for概述及使用
增强for概述
简化数组和Collection集合的遍历
格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
好处：简化遍历
注意事项：增强for的目标要判断是否为null
public static void main(String[] args) {
int[] arr={11,22,33,44,55};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("================");
for(int i:arr){
System.out.println(i);
}
}
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("hello");
arrayList.add("world");
arrayList.add("java");
if(arrayList!=null){
for (String s : arrayList) {
System.out.println(s);
}
}
}
六、静态导入概述及使用
静态导入概述
格式：import static 包名….类名.方法名;
可以直接导入到方法的级别
注意事项
方法必须是静态的
如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂。
七、可变参数概述及使用
可变参数概述
定义方法的时候不知道该定义多少个参数
格式
修饰符 返回值类型 方法名(数据类型… 变量名){}
注意：
这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
Arrays工具类中的一个方法（把数组转换成集合）
public static <T> List<T> asList(T... a)
public static void main(String[] args) {
String[] arr={"hello","world","java"};
List<String> list= Arrays.asList(arr);
for(String s:list){
System.out.println(s);
}
}
八、List集合练习
8.1、集合的嵌套遍历
public static void main(String[] args) {
ArrayList<ArrayList<Student>> bigarr = new ArrayList<ArrayList<Student>>();
ArrayList<Student> arr1 = new ArrayList<Student>();
Student s1 = new Student("唐僧",23);
Student s2 = new Student("猪八戒",28);
Student s3 = new Student("孙悟空",30);
arr1.add(s1);
arr1.add(s2);
arr1.add(s3);
ArrayList<Student> arr2 = new ArrayList<Student>();
Student s4 = new Student("周瑜",23);
Student s5 = new Student("诸葛亮",28);
arr2.add(s4);
arr2.add(s5);
bigarr.add(arr1);
bigarr.add(arr2);
for(ArrayList<Student> array:bigarr){
for(Student s:array){
System.out.println(s);
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
