目录
1、关于List接口
1)List集合存储元素特点:有序可重复
有序:List集合中的元素有下标,从0开始,以1递增;
可重复:存储一个1,还可以再存储1;
2)List接口中特有的常用方法:
添加元素到指定位置 void add(int index,E element)
返回列表中指定位置的元素 Object get(int index)
返回列表中第一个出现的指定元素的索引,如果不包含返回-1 int intdexOf(Object c)
返回列表中最后出现的指定元素的索引,如果不包含返回-1 int lastIndexOf(Object c)
移除列表中指定位置的元素(可选操作) Object move(Object o)
用指定元素替换列表中指定位置的元素(可选操作) Object set(int index,E element)
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class asdf{
public static void main(String[] args) {
//调用List特有的方法需要创建List引用
List myList = new ArrayList();
//添加元素
myList.add("A");//默认都向集合末尾添加元素
myList.add("B");
myList.add("C");
myList.add("D");
myList.add("E");
//在列表的指定位置插入元素(第一个参数是下标)
myList.add(1,"KING");//这个方法使用的不多,因为效率太低
//迭代
Iterator it = myList.iterator();
while(it.hasNext()){
Object ect = it.next();
System.out.println(ect);
}
//根据下标获取元素
Object firstObj = myList.get(0);
System.out.println(firstObj);
//因为有下标,所以List集合有自己比较独特的遍历方式【通过下标】
for(int i = 0;i<mylist.size();i++){
Object obj = myList.get(i);
System.out.println(obj);
}
}
}
2、ArrayList集合
2.1 Arrays工具类的使用
判断两个数组是否相等。 boolean equals(int[] a,int[] b)
输出数组信息。 String toString(int[] a)
将指定值填充到数组之中。 void fill(int[] a,int val)
对数组进行排序。 void sort(int[l a)
对排序后的数组进行二分法检索指定的值。 int binarySearch(int[] a,int key)
2.2 初始化容量
1)默认初始化容量是10(JDK13新特性:底层先创建了一个长度为0的数组,当添加第一个元素的时候,初始化容量为10)
注意:size方法测的是集合中元素的个数,不是集合的容量
2)集合底层是一个Object [ ] 数组
3)构造方法:
new ArrayList();
new ArrayList(20);
//指定初始化容量100
List myList2 = new ArrayList(100);
//创建一个HashSet集合
Collection c = new HashSet();
//添加元素到Set集合
c.add(100);
c.add(200);
c.add(900);
//通过这个构造方法就可以将HashSet集合转换成List集合
List myList3 = new ArrayList(c);
for(int i =0;i<myList3.size();i++){
System.out.println(myList3.get(i));
}
2.3 扩容
1)默认初始化容量是10,容量满了之后如果再添加元素,自动扩容,扩容的大小是原来的1.5倍
2)ArrayList的底层是数组,尽可能少的扩容,因为数组扩容效率比较低。建议在使用ArrayList的是初始化容量给顶一个预估计的初始化容量,减少扩容
2.4 关于数组
优点:检索效率比较高;
缺点:随机增删元素的效率比较低;
向数组元素末尾添加元素,效率很高,不受影响;
3、位运算
// 5 // >> 1 二进制右移1位 // >> 2 二进制右移2位 // 10的二进制:00001010 【10】 // 10的二进制右移1位是:00000101 【5】
左移是乘以,右移是除以 2的n次方倍,n为移动的位数
4、LinkedList集合
4.1 链表的优缺点
链表的优点:空间存储内存地址不连续,随机增删元素效率较高(因为增删元素不涉及到大量的元素位移)
链表的缺点:查询效率较低,每一次查找某个元素的时候都需要从头节点开始往下遍历
ArrayList之所以检索效率高,不是单纯因为下标的原因,是因为底层数组发挥的作用
LinkedList集合照样有下标,但是检索某个元素的时候效率比较低,因为只能从头节点开始一个一个遍历
4.2 Java实现单链表
public class asdf{
public static void main(String[] args) {
Link link = new Link();
link.add(100);
link.add(200);
link.add(300);
System.out.println(link.size);
}
}
class Node{
//存储的数据
Object data;
//下一个结点的内存地址
Node next;
public Node(){
}
public Node(Object data,Node next){
this.data = data;
this.next = next;
}
}
class Link {
//头指针
Node header = null;
int size = 0;
public int size(){
return size;
}
//向链表中添加元素的方法
public void add(Object data) {
//创建一个新的节点对象
//让之前单链表的末尾节点next指向新节点对象
if(header == null) {
//说明还没有节点,new一个新的节点对象,作为头节点对象
header = new Node(data,null);
}else{
//说明头结点已经有了
//找出当前末尾节点,让当前末尾节点的next是新节点
Node currentLastNode = findLast(header);
currentLastNode.next = new Node(data,null);
}
size++;
}
//专门查找末尾结点的方法
private Node findLast(Node node) {
if(node.next == null) {
//如果节点的next是空则为末尾节点
return node;
}
return findLast(node.next);//递归
}
//删除链表中的某个数据的方法
public void remove(Object obj){
}
//修改链表中的某个数据元素的方法
public void modify(Object newobj){
}
//查找链表中某个元素的方法
public int find(Object obj){
return 1;
}
}
4.3 关于LinkedList
1)LinkedList集合没有初始化容量
2)最初这个链表中没有任何元素。first和last引用都是null
3)不管是LinkedList还是ArrayList,以后写代码不需要关系是哪个集合,我们需要面向接口编程,调用的方法都是接口中的方法
List list2 = new ArrayList();//这样写表示底层用的是数组
List list2 = new LinkedList();//这样写表示底层用的是双向链表
List2.add("123");
List2.add("456");
List2.add("789");
//这些方法都是面向的是接口编程
5、Vector集合
5.1 关于Vector集合
1)底层是一个数组
2)初始化容量是10
3)超过10后自动扩容,每次扩容是原容量的2倍
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class java{
public static void main(String[] args) {
List l = new Vector();
l.add("123");
l.add("456");
l.add("789");
l.add("122");
Iterator as = l.iterator();
while(as.hasNext()){
Object object = as.next();
System.out.println(object);
}
}
}
4)Vector中的所有方法都是线程同步的,都带有synchronized关键字,是线程安全的。效率较低,使用较少
5.2 将不安全的ArrayList集合转换成线程安全
使用集合工具类 java.utill.Collections;
注意:java.utill.Collection 是集合接口
java.utill.Collections 是集合工具类
List myList = new ArrayList();//非线程安全的
//变成线程安全的
Collection.synchronizedList(myList);
//现在mylist就是线程安全的了
6、泛型
6.1 关于泛型
jdk1.5后的新特性
泛型这种语法机制只能在程序编译阶段起作用,只是给编译器参考的【运行阶段泛型意义不大】
优点:
1)集合中存储的元素类型统一了
2)从集合中取出的元素类型是泛型指定的类型,不需要进行大量的"向下转型"
缺点:
1)导致集合中元素缺乏多样性
2)调用父类中特有的方法不需要向下转型,但调用子类中特有的方法还是需要向下转型
6.2 泛型的具体使用
public class java{
public static void main(String[] args) {
/*List l = new Vector();
Cat cat = new Cat();
Dog dog = new Dog();
l.add(cat);
l.add(dog);
Iterator it = l.iterator();
while(it.hasNext()){
Object object = it.next();
// 使用泛型前需要向下转型
if(object instanceof Animal){
Animal a =(Animal)object;
a.move();
}
}*/
//使用泛型后
List <Animal> l = new Vector<Animal>();
//指定list集合只能存储Animal,那么存储String就编译报错了
//这样使用泛型之后,集合中元素的数据类型更加统一
Cat cat = new Cat();
Dog dog = new Dog();
l.add(cat);
l.add(dog);
//获取迭代器
//表示迭代器迭代的是Animal类型
Iterator <Animal>it = l.iterator();
while(it.hasNext()){
//使用迭代之后返回的数据都是Animal类型的,不需要强制类型转换
Animal a= it.next();
a.move();
}
}
}
class Animal{
public void move(){
System.out.println("动物在移动");
}
}
class Cat extends Animal{
public void move(){
System.out.println("猫在吃鱼");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗在吃肉");
}
}
6.3 类型自动推断【钻石表达式】
ArrayList<这里的类型会自动推断>(),前提是jdk8之后才允许
List <Animal> myList = new ArrayList <> ();
6.4 自定义泛型
<>尖括号里面的是一个标识符,随便写
一般是<E>,<T>
E是Element单词首字母
T是Type单词首字母
public class asdf<E>{
public void Do(E o){
System.out.println(o);
}
public static void main(String[] args) {
asdf<String> gt = new asdf<>();
gt.Do("ssd");
}
}
7、foreach【增强for循环】
jdk5.0之后的新特性
7.1 语法格式
for(元素类型 变量名:数组或集合){ System.out.println(变量名); }
7.2 增强for(foreach)
int[] arr = {43,34,3241,5463,23,1};
for(int data:arr){
System.out.println(data);
}
data代表数组中的每一个元素,可以改变
缺点:没有下标
7.3 集合使用foreach
//创建List集合
List<String>strList = new ArrayList<>();
//添加元素
strList.add("hello");
strList.add("world");
strList.add("kitty");
//遍历使用选代器方式
Iterator<String> it = strlist.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
//使用下标方式(只针对于有下标的集合)
for(int i = B; i < strList.size(); i++){
System.out.println(strList.get(i));
}
//使用oreach
for(String s:strlist){ // 因为泛型使用的是String关星,所以是:String s
System.out.println(s);
}