网站建设自助搭配系统,wordpress前台编辑,福州网站设计网址,宁波公司建站模板集合集合的理解和好处保存多个数据使用的是数组#xff0c;分析数组的弊端数组1、长度开始必须指定#xff0c;而且一旦指定#xff0c;不能更改2、保存的必须为同一类型的元素3、使用数组进行增加/删除元素的示意代码-比较麻烦Person数组扩容示意代码Person[] pers new Pe…集合集合的理解和好处保存多个数据使用的是数组分析数组的弊端数组1、长度开始必须指定而且一旦指定不能更改2、保存的必须为同一类型的元素3、使用数组进行增加/删除元素的示意代码-比较麻烦Person数组扩容示意代码Person[] pers new Person[1];//大小是1
pers[0] new Person();
//增加新的Person对象
Person[] pers2 new Person[pers.length 1];//创建新数组
for(){}//拷贝pers数组的元素到pers2
pers2[pers2.length - 1] new Person();//添加新的对象集合1、可以动态保存任意多个对象使用比较方便2、提供了一系列方便的操作对象的方法add、remove、set、get等3、使用集合添加删除新元素的示意代码-简洁集合的框架体系Java的集合类很多主要分为两大类如图package com14.collection_;import java.util.ArrayList;
import java.util.HashMap;/*** author 甲柒* version 1.0* title Collection_* package com14.collection_* time 2023/1/13 17:53*/
public class Collection_ {SuppressWarnings({all})public static void main(String[] args) {//解读//1.集合主要是两组(单列集合双列集合)//2.Collection接口有两个重要的子接口 List Set他们的实现子类都是单列集合//3.Map接口的实现子类是双列集合存放的 K-V
// Collection
// MapArrayList arrayList new ArrayList();arrayList.add(jack);arrayList.add(tom);HashMap hashMap new HashMap();hashMap.put(NO1, 北京);hashMap.put(NO2, 上海);}
}
Collection接口和常用方法Collection接口实现类的特点public interface CollectionE extends lterableE1、Collection实现子类可以存放多个元素每个元素可以是Object2、有些Collection的实现类可以存放重复的元素有些不可以3、有些Collection的实现类有些是有序的(List)有些不是有序(Set)4、Collection接口没有直接的实现子类是通过它的子接口Set和List来实现的Collection接口和常用方法1、add //添加单个元素2、remove //删除指定元素3、contains //查找元素是否存在4、size //获取元素个数5、isEmpty //判断是否为空6、clear //清空7、addAll //添加多个元素8、containsAll //查找多个元素是否都存在9、removeAll //删除多个元素10、说明以ArrayList实现类来演示package com14.collection_;import java.util.ArrayList;/*** author 甲柒* version 1.0* title CollectionMethod* package com14.collection_* time 2023/1/13 18:42*/
public class CollectionMethod {SuppressWarnings({all})public static void main(String[] args) {ArrayList arrayList new ArrayList();//1、add //添加单个元素arrayList.add(jack);arrayList.add(10);arrayList.add(true);System.out.println(arrayList arrayList);//2、remove //删除指定元素
// arrayList.remove(0);//删除第一个元素arrayList.remove(true);//指定删除某个元素System.out.println(arrayList arrayList);//3、contains //查找元素是否存在System.out.println(arrayList.contains(jack));//true//4、size //获取元素个数System.out.println(arrayList.size());//2//5、isEmpty //判断是否为空System.out.println(arrayList.isEmpty());//false//6、clear //清空arrayList.clear();System.out.println(arrayList arrayList);//7、addAll //添加多个元素ArrayList arrayList1 new ArrayList();arrayList1.add(西游记);arrayList1.add(三国演义);arrayList.addAll(arrayList1);System.out.println(arrayList arrayList);//8、containsAll //查找多个元素是否都存在System.out.println(arrayList.containsAll(arrayList1));//true//9、removeAll //删除多个元素arrayList.add(鬼吹灯);arrayList.removeAll(arrayList1);System.out.println(arrayList arrayList);//鬼吹灯//10、说明以ArrayList实现类来演示}
}
Collection接口遍历元素方式1-使用Iterator(迭代器)基本介绍1、Iterator对象称为迭代器,主要用于遍历Collection集合中的元素。2、所有实现了Collection接口的集合类都有一个iterator()方法用以返回一个实现了lterator接口的对象即可以返回一个迭代器。3、Iterator的结构。[图:]4、Iterator仅用于遍历集合Iterator本身并不存放对象。迭代器的执行原理Iterator iterator coll.iterator();//得到一个集合的迭代器//hasNext():判断是否还有下一个元素while(iterator.hasNext()){//next()作用:1.指针下移2.将下移以后集合位置上的元素返回System.out.println(iterator.next());}Iterator接口的方法注意在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用且下一条记录无效直接调用itterator.next()会抛出NoSuchElementException异常package com14.collection_;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;/*** author 甲柒* version 1.0* title CollectionIterator* package com14.collection_* time 2023/1/28 17:44*/
public class CollectionIterator {SuppressWarnings({all})public static void main(String[] args) {Collection collection new ArrayList();collection.add(new Book(三国演义, 罗贯中, 49.9));collection.add(new Book(三体, 刘慈欣, 139.9));collection.add(new Book(流浪地球, 刘慈欣, 69.9));// System.out.println(collection collection);//现在希望能够遍历collection集合//1.先得到collection对应的迭代器Iterator iterator collection.iterator();//2.使用while循环遍历
// while (iterator.hasNext()) {//判断是否还有数据
// //返回下一个元素类型是Objext
// Object obj iterator.next();
// System.out.println(obj obj);
// }//快捷键 快速生成while itit//显示所有快捷键的快捷键 ctrl jwhile (iterator.hasNext()) {Object next iterator.next();System.out.println(next);}//3.当退出while循环后这时iterator迭代器指向最后的元素
// iterator.next();//NoSuchElementException//4.如果希望再次遍历需要重置迭代器iterator collection.iterator();System.out.println(第2次遍历);while (iterator.hasNext()) {Object next iterator.next();System.out.println(next);}}
}class Book {private String name;private String author;private double price;public Book(String name, String author, double price) {this.name name;this.author author;this.price price;}public String getName() {return name;}public void setName(String name) {this.name name;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author author;}public double getPrice() {return price;}public void setPrice(double price) {this.price price;}Overridepublic String toString() {return Book{ name name \ , author author \ , price price };}
}Collection接口遍历对象方式2-for循环增强增强for循环可以代替iterator迭代器特点增强for就是简化版的iterator本质一样 。只能用于遍历集合或数组。基本语法for(元素类型 元素名:集合名或数组名){访问元素
}案例演示package com14.collection_;import java.util.ArrayList;
import java.util.Collection;/*** author 甲柒* version 1.0* title CollectionFor* package com14.collection_* time 2023/1/28 18:11*/
public class CollectionFor {SuppressWarnings({all})public static void main(String[] args) {Collection collection new ArrayList();collection.add(new Book(三国演义, 罗贯中, 49.9));collection.add(new Book(三体, 刘慈欣, 139.9));collection.add(new Book(流浪地球, 刘慈欣, 69.9));//解读//1.使用增强for在Collection集合//2.增强for底层仍然是迭代器//3.增强for可以理解成就是简化版的 迭代器遍历for (Object book :collection) {System.out.println(book);}//增强for也可以直接在数组使用
// int[] nums {1, 8, 10, 99};
// for (int i : nums) {
// System.out.println(i i);
// }}
}
练习题请编写程序1、创建3个 Dog {name, age} 对象放入到 ArrayList中赋给List 引用2、用迭代器和增强for循环两种方式来遍历3、重写Dog的toString方法输出name和agepackage com14.collection_;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;/*** author 甲柒* version 1.0* title CollectionExercise* package com14.collection_* time 2023/1/28 18:21*/
public class CollectionExercise {SuppressWarnings({all})public static void main(String[] args) {List list new ArrayList();list.add(new Dog(大黄, 5));list.add(new Dog(大白, 10));list.add(new Dog(大黑, 3));//先使用for增强for (Object dog : list) {System.out.println(dog dog);}//使用迭代器System.out.println(使用迭代器);Iterator iterator list.iterator();while (iterator.hasNext()) {Object dog iterator.next();System.out.println(dog dog);}}
}/*** 1、创建3个 Dog {name, age} 对象放入到 ArrayList中赋给List 引用* 2、用迭代器和增强for循环两种方式来遍历* 3、重写Dog的toString方法输出name和age*/
class Dog {private String name;private int age;public Dog(String name, int age) {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;}Overridepublic String toString() {return Dog{ name name \ , age age };}
}List接口和常用方法List接口基本介绍List接口是Collection接口的子接口List集合类中的元素有序(即添加顺序和取出顺序一致)、且可重复List集合中的每个元素都有其对应的顺序索引即支持索引List容器中的元素都对应一个整数类型的序号记载其在容器中的位置可以根据序号存取容器中的元素JDK API中List接口的实现类有package com14.list_;import java.util.ArrayList;
import java.util.List;/*** author 甲柒* version 1.0* title List_* package com14.list_* time 2023/2/20 9:34*/
public class List_ {public static void main(String[] args) {//1.List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复List list new ArrayList();list.add(tom);list.add(jack);list.add(marry);list.add(lsp);list.add(lsp);System.out.println(list list);//2.List集合中的每个元素都有其对应的顺序索引即支持索引System.out.println(list.get(2));}
}
List接口的常用方法List集合里添加了一些根据索引来操作集合元素的方法void add(int index, Object ele):在index位置插入ele元素boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来Object get(int index):获取指定index位置的元素int indexOf(Object obj):返回obj在集合中首次出现的位置int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置Object remove(int index):移除指定index位置的元素并返回此元素Object set(int index, Object ele):设置指定index位置的元素为ele相当于是替换List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合package com14.list_;import java.util.ArrayList;
import java.util.List;/*** author 甲柒* version 1.0* title ListMethod* package com14.list_* time 2023/2/20 10:36*/
public class ListMethod {SuppressWarnings({all})public static void main(String[] args) {List list new ArrayList();list.add(渣渣辉);list.add(唐玄奘);
// void add(int index, Object ele):在index位置插入ele元素//在index 1的位置插入一个对象list.add(1, 甲柒);System.out.println(list list);
// boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来List list2 new ArrayList();list2.add(jack);list2.add(tom);list.addAll(1, list2);System.out.println(list list);
// Object get(int index):获取指定index位置的元素System.out.println(list.get(2));
// int indexOf(Object obj):返回obj在集合中首次出现的位置System.out.println(list.indexOf(tom));
// int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置list.add(甲柒);System.out.println(list list);System.out.println(list.lastIndexOf(甲柒));
// Object remove(int index):移除指定index位置的元素并返回此元素list.remove(0);System.out.println(list list);
// Object set(int index, Object ele):设置指定index位置的元素为ele相当于是替换list.set(1, 沈腾);System.out.println(list list);
// List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合List list1 list.subList(0, 2);System.out.println(list1 list1);}
}
List接口练习题1添加10个以上的元素(比如String hello)在2号位插入一个元素甲柒获得第5个元素删除第6个元素修改第7个元素在使用迭代器遍历集合要求使用List的实现类ArrayList完成。package com14.list_;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;/*** author 甲柒* version 1.0* title ListExercise* package com14.list_* time 2023/2/20 18:55*/
public class ListExercise {// 添加10个以上的元素(比如String hello)
// 在2号位插入一个元素甲柒获得第5个元素
// 删除第6个元素修改第7个元素在使用迭代器遍历集合
// 要求使用List的实现类ArrayList完成。SuppressWarnings({all})public static void main(String[] args) {List list new ArrayList();for (int i 0; i 12; i) {list.add(hello i);}System.out.println(List list);
// 在2号位插入一个元素甲柒list.add(1, 甲柒);System.out.println(List list);
// 获得第5个元素System.out.println(第五个元素 list.get(4));
// 删除第6个元素list.remove(5);System.out.println(List list);
// 修改第7个元素list.set(6, java);System.out.println(List list);
// 在使用迭代器遍历集合Iterator iterator list.iterator();while (iterator.hasNext()) {Object next iterator.next();System.out.println(next next);}}
}
List三种遍历方式[ArrayList、Linked、Vector]package com14.list_;import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;/*** author 甲柒* version 1.0* title ListFor* package com14.list_* time 2023/2/20 19:12*/
public class ListFor {SuppressWarnings({all})public static void main(String[] args) {
// List 接口的实现子类 LinkedList
// List list new ArrayList();
// List list new Vector();List list new LinkedList();list.add(蟹老板);list.add(章鱼哥);list.add(海绵宝宝);list.add(派大星);//遍历//1.迭代器System.out.println(迭代器);Iterator iterator list.iterator();while (iterator.hasNext()) {Object next iterator.next();System.out.println(next);}System.out.println(增强for);//2.增强forfor (Object o : list) {System.out.println(o);}System.out.println(普通for);//3.普通forfor (int i 0; i list.size(); i) {System.out.println(list.get(i));}}
}
List接口练习题2使用List的实现类添加三本书并遍历打印效果如下要求按价格排序从低到高(使用冒泡排序)使用ArrayList、LinkedList、Vector三种集合实现package com14.list_;import java.util.LinkedList;
import java.util.List;/*** author 甲柒* version 1.0* title ListExercise02* package com14.list_* time 2023/2/20 19:30*/
SuppressWarnings({all})
public class ListExercise02 {public static void main(String[] args) {
// List list new ArrayList();List list new LinkedList();
// List list new Vector();list.add(new Book(红楼梦, 39, 曹雪芹));list.add(new Book(西游记, 100, 吴承恩));list.add(new Book(水浒传, 9.9, 施耐庵));list.add(new Book(三国演义, 88, 罗贯中));
// list.add(new Book(红楼梦,39,曹雪芹));//遍历for (Object o : list) {System.out.println(o);}//冒泡排序sort(list);System.out.println(排序后);//遍历for (Object o : list) {System.out.println(o);}}//静态方法public static void sort(List list) {int listSize list.size();for (int i 0; i listSize - 1; i) {for (int j 0; j listSize - 1 - i; j) {//取出对象BookBook book1 (Book) list.get(j);Book book2 (Book) list.get(j 1);if (book1.getPrice() book2.getPrice()) {list.set(j, book2);list.set(j 1, book1);}}}}
}ArryList的注意事项permits all elementsincluding nullArrayList可以加入null并且多个ArrayList是由数组来实现数据存储的ArrayList基本等同于Vector除了ArrayList是线程不安全(执行效率高)在多线程情况下不建议使用ArrayListpackage com14.list_;import java.util.ArrayList;/*** author 甲柒* version 1.0* title ArrayListDetail* package com14.list_* time 2023/2/21 19:46*/
SuppressWarnings({all})
public class ArrayListDetail {public static void main(String[] args) {//ArrayList是线程不安全的源码中没有synchronized/*public boolean add(E e) {ensureCapacityInternal(size 1); // Increments modCount!!elementData[size] e;return true;}*/ArrayList arrayList new ArrayList();arrayList.add(null);arrayList.add(jack);arrayList.add(null);System.out.println(arrayList);}
}ArrayList底层结构和源码分析ArrayList的底层操作机制源码分析1、ArrayList中维护了一个Object类型的数组elementDatatransient Object[] elementData;//transient表示瞬间短暂的表示该属性不会被序列号2、当创建ArrayList对象时如果使用的是无参构造器则初始elementData容量为0第1次添加则扩容elementData为10如需再次扩容则扩容elementData为1.5倍3、如果使用的是指定大小的构造器则初始elementData容量为指定大小如需要扩容则直接扩容elementData为1.5倍package com14.list_;import java.util.ArrayList;/*** author 甲柒* version 1.0* title ArrayListSource* package com14.list_* time 2023/2/21 21:41*/
SuppressWarnings({all})
public class ArrayListSource {public static void main(String[] args) {//解读//使用无参构造器创建ArrayList对象ArrayList list new ArrayList();//ArrayList list new ArrayList(8);//使用for给list集合添加1-10数据for (int i 1; i 10; i) {list.add(i);}//使用for给list集合添加11-15数据for (int i 11; i 15; i) {list.add(i);}list.add(100);list.add(200);list.add(null);}
}Vector底层结构和源码剖析Vector的基本介绍1、Vector类的定义说明2、Vector底层也是一个对象数组protected Object[] elementData3、Vector是线程同步的即线程安全Vector类的操作方法带有synchronized4、在开发中需要线程同步安全时考虑使用VectorVector底层结构和ArrayList的比较Vector和ArrayList的比较LinkedList底层结构LiskedList的全面说明LiskedList底层实现了双向链表和双端队列特点可以添加任意元素(元素可以重复)包括null线程不安全没有实现同步LiskedList的底层操作机制LinkedList底层维护了一个双向链表LinkedList中维护了两个属性first和last分别指向首节点和尾节点每个节点(Node对象)里又维护了prev、next、item三个属性其中通过prev指向前一个节点通过next指向后一个节点最终实现双链表所以LinkedList的元素的添加和删除不是通过数组完成的相对来说效率较高模拟一个简单的双链表package com14.list_;/*** author 甲柒* version 1.0* title LinkedList* package com14.list_* time 2023/2/21 22:55*/
public class LinkedList {public static void main(String[] args) {//模拟一个简单的双向链表Node jack new Node(jack);Node tom new Node(tom);Node jerry new Node(jerry);//连接三个结点形成双向链表//jack - tom - jerryjack.next tom;tom.next jerry;//jerry - tom - jackjerry.pre tom;tom.pre jack;Node first jack;//让first引用指向jack,就是双向链表的头结点Node last jerry;//让last引用指向hsp,就是双向链表的尾结点//演示从头到尾进行遍历System.out.println(从头到尾进行遍历);while (true) {if (first null) {break;}//输出first 信息System.out.println(first);first first.next;}//演示从尾到头的遍历System.out.println(从尾到头的遍历);while (true) {if (last null) {break;}//输出last 信息System.out.println(last);last last.pre;}//演示链表的添加对象/数据是多么的方便//要求是在 tom --------- 老韩直接插入一个对象 smith//1. 先创建一个 Node 结点name 就是 smithNode smith new Node(smith);//下面就把 smith 加入到双向链表了smith.next jerry;smith.pre tom;jerry.pre smith;tom.next smith;//让first 再次指向jackfirst jack;//让first引用指向jack,就是双向链表的头结点System.out.println(从头到尾进行遍历);while (true) {if (first null) {break;}//输出first 信息System.out.println(first);first first.next;}last jerry; //让last 重新指向最后一个结点//演示从尾到头的遍历System.out.println(从尾到头的遍历);while (true) {if (last null) {break;}//输出last 信息System.out.println(last);last last.pre;}}
}//定义一个Node 类Node 对象 表示双向链表的一个结点
class Node {public Object item; //真正存放数据public Node next; //指向后一个结点public Node pre; //指向前一个结点public Node(Object name) {this.item name;}public String toString() {return Node name item;}
}
LinkedList的增删改查案例package com14.list_;import java.util.Iterator;
import java.util.LinkedList;/*** author 甲柒* version 1.0* title LInkedListCRUD* package com14.list_* time 2023/2/22 20:22*/
SuppressWarnings({all})
public class LInkedListCRUD {public static void main(String[] args) {LinkedList linkedList new LinkedList();linkedList.add(1);linkedList.add(2);linkedList.add(3);System.out.println(linkedList linkedList);//演示一个删除结点的linkedList.remove(); // 这里默认删除的是第一个结点//linkedList.remove(2);System.out.println(linkedList linkedList);//修改某个结点对象linkedList.set(1, 999);System.out.println(linkedList linkedList);//得到某个结点对象//get(1) 是得到双向链表的第二个对象Object o linkedList.get(1);System.out.println(o);//999//因为LinkedList 是 实现了List接口, 遍历方式System.out.println(LinkedList遍历迭代器);Iterator iterator linkedList.iterator();while (iterator.hasNext()) {Object next iterator.next();System.out.println(next next);}System.out.println(LinkedList遍历增强for);for (Object o1 : linkedList) {System.out.println(o1 o1);}System.out.println(LinkedList遍历普通for);for (int i 0; i linkedList.size(); i) {System.out.println(linkedList.get(i));}//源码阅读./* 1. LinkedList linkedList new LinkedList();public LinkedList() {}2. 这时 linkedList 的属性 first null last null3. 执行 添加public boolean add(E e) {linkLast(e);return true;}4.将新的结点加入到双向链表的最后void linkLast(E e) {final NodeE l last;final NodeE newNode new Node(l, e, null);last newNode;if (l null)first newNode;elsel.next newNode;size;modCount;}*//*读源码 linkedList.remove(); // 这里默认删除的是第一个结点1. 执行 removeFirstpublic E remove() {return removeFirst();}2. 执行public E removeFirst() {final NodeE f first;if (f null)throw new NoSuchElementException();return unlinkFirst(f);}3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉private E unlinkFirst(NodeE f) {// assert f first f ! null;final E element f.item;final NodeE next f.next;f.item null;f.next null; // help GCfirst next;if (next null)last null;elsenext.prev null;size--;modCount;return element;}*/}
}ArrayList和LinkedList比较ArrayList和LinkedList比较如何选择ArrayList和LinkedList如果改查的操作多选择ArrayList如果增删的操作多选择LinkedList一般来说在程序中80%~90%都是查询因此大部分情况下会选择ArrayList在一个项目中根据业务灵活选择也可以这样一个模块使用的是ArrayList另一个模块是LinkedList
