首页 > 编程语言 >10.Java集合框架_List接口

10.Java集合框架_List接口

时间:2024-10-04 21:23:33浏览次数:7  
标签:10 Java ArrayList List System add println out

集合与数组的区别

  • 数组:
    1. 长度开始时必须指定,而且一旦指定,不能修改
    2. 保存的必须为同一类型的元素
    3. 使用数组进行增加/删除元素比较麻烦
  • 集合:
    1. 可以动态保存任意多个对象,使用比较方便
    2. 提供了一系列方便操作对象的方法: add、remove、set、get
    3. 使用集合添加,删除新元素的代码简洁明了

Collection体系框架图

单列集合

collection体系框架图_单列集合

双列集合

collection体系框架图_双列集合

Collection接口和常用方法

特点:

  1. collection实现子类可以存放多个元素,每个元素可以是Object。

  2. 有些Collection的实现类,可以存放重复的元素,有些不可以。

  3. 有些Collection的实现类,是有序的(List),有些不是有序的(Set)。

    有序:指存取顺序一致

  4. Collection接口没有直接的实现子类,是通过它的子接口Set和List来实现的。

操作元素方法

  1. add:添加单个元素。
  2. remove:删除指定元素。
  3. contains:查找元素是否存在。
  4. size:获取元素个数。
  5. isEmpty:判断是否为空。
  6. clear:清空。
  7. addAll:添加多个元素。
  8. containsAll:查找多个元素是否都存在。
  9. removeAll:删除多个元素。

代码:

import java.util.ArrayList;

//集合操作元素方法
public class Demo {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();

        //1.add:添加单个元素
        arrayList.add("jack");
        arrayList.add(10); //arrayList.add(new Integer(10)); 自动装箱
        arrayList.add(true);
        System.out.println("List:" + arrayList); //List:[jack, 10, true]

        //2.remove:删除指定元素
        Object first = arrayList.remove(0); //删除第一个元素
        System.out.println("删除的第一个元素为:" + first); //删除的第一个元素为:jack
        arrayList.remove("jack");
        arrayList.remove(new Integer(10)); //这里就没有默认装箱了,输入10会删除第十一个元素
        System.out.println("List:" + arrayList); //List:[true]

        //3.contains:查找元素是否存在
        System.out.println(arrayList.contains("jack")); //false

        //4.size:获取元素个数
        System.out.println(arrayList.size()); //1

        //5.isEmpty:判断是否为空
        System.out.println(arrayList.isEmpty()); //false

        //6.clear:清空
        arrayList.clear();
        System.out.println("List:" + arrayList); //List:[]

        //7.addAll:添加多个元素
        ArrayList<Object> arrayList1 = new ArrayList<>();
        arrayList1.add("红楼梦");
        arrayList1.add("西游记");
        arrayList1.add("水浒传");
        arrayList1.add("三国演义");
        arrayList.addAll(arrayList1);
        System.out.println("List:" + arrayList); //List:[红楼梦, 西游记, 水浒传, 三国演义]

        //8.containsAll:查找多个元素是否都存在
        System.out.println(arrayList.containsAll(arrayList1)); //true

        //9.removeAll:删除多个元素
        ArrayList<Object> arrayList2 = new ArrayList<>();
        arrayList2.add("红楼梦");
        arrayList2.add("西游记");
        arrayList.removeAll(arrayList2);
        System.out.println("List:" + arrayList); //List:[水浒传, 三国演义]
    }
}

使用迭代器遍历

基本介绍

  1. Iterator对象称为迭代器,主要用于遍历Collection集合中的元素。
  2. 所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器。
  3. Iterator的结构
  4. Iterator仅用于遍历集合,Iterator本身并不存放对象。

迭代器执行原理

//得到一个集合的迭代器
Iterator iterator = collection.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
    //next()作用: 1.下移 2.将下移以后集合位置上的元素返回
    System.out.printIn(iterator.next());
}

iterator接口方法

返回类型 方法 描述
boolean hasNext() 如果迭代具有更多元素,则返回true
E next() 返回迭代中的下一个元素
default void remove() 从底层集合中删除此迭代器返回的最后一个元素(可选操作)。
default void forEachRemaining(Consumer action) 对每个剩余元素执行给定的操作,直到所有元素都被处理或动作引发异常。

代码:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//迭代器遍历集合
public class CollectionIterator {
    @SuppressWarnings({"all"}) //警告抑制
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("红楼梦");
        collection.add("三国演义");
        collection.add("西游记");
        collection.add("水浒传");
        System.out.println(collection);

        //迭代器遍历集合
        //1.得到集合对应的迭代器
        Iterator iterator = collection.iterator();

        //2.使用while循环遍历
        while (iterator.hasNext()) { //判断是否还有元素
            //返回下一个元素,类型是Object
            Object object = iterator.next(); //编译类型是Object,运行类型取决于对象实际类型
            System.out.println("object:" + object);
        }

        //快捷键快速生成该while循环 ==> itit
        //CTRL+J 显示所有快捷键选项
        //while (iterator.hasNext()) {
        //    Object next =  iterator.next();
        //}

        //3.当退出while循环后,这时iterator迭代器指向最后一个元素
        //iterator.next(); //报错:NoSuchElementException

        //4.重新遍历
        iterator = collection.iterator();
        while (iterator.hasNext()) { //判断是否还有元素
            //返回下一个元素,类型是Object
            Object object = iterator.next(); //编译类型是Object,运行类型取决于对象实际类型
            System.out.println("new object:" + object);
        }

    }
}

增强for循环遍历

增强for循环,可以替代iterator迭代器,特点:增强for就是简化版的iterator,本质一样。只能用于遍历集合或数组。

基本语法

for(元素类型 元素名 : 集合名或数组名){
    访问元素
}

代码:

import java.util.ArrayList;
import java.util.Collection;

//增强for循环遍历集合
public class CollectionFor {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("红楼梦");
        collection.add("三国演义");
        collection.add("西游记");
        collection.add(new book("三国演义","罗贯中",20.2));
        collection.add(new book("红楼梦","曹雪芹",150.3));
        collection.add(new book("西游记","吴承恩",25.3));
        System.out.println(collection);

        //增强for循环的底层实现依旧是迭代器
        //增强for循环可以理解为简化版的迭代器
        //快捷键 ==> I
        //CTRL+J 显示所有快捷键选项
        //for (Object object :) {
        //
        //}

        //增强for循环遍历集合
        for (Object object : collection) {
            System.out.println(object);
        }


    }
}

class book{
    public String name;
    public String author;
    public 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;
    }

    @Override
    public String toString() {
        return "book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

List接口方法

List接口基本介绍

List接口是Collection接口的子接口。

  1. List集合类中元素有序(即添加顺序和取出顺序一致)且可重复。
  2. List集合中的每个元素都有其对应的顺序索引,即支持索引。
  3. List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
  4. List接口常用的实现类有很多,常用的有:ArrayList、LinkedList 和 Vector。

常用方法

方法 描述
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 位置的子集合

代码:

import java.util.ArrayList;
import java.util.List;

//List常用方法
public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Tom");
        list.add("Jerry");
        list.add("Jack");

        //1.void add ( int index , Object ele )
        //在index位置插入ele元素
        list.add(1, "Jack"); //在index=1的位置插入一个对象"jack"
        System.out.println(list); //[Tom, Jack, Jerry, Jack]

        //2.boolean addAll ( int index , Collection eles )
        //从index位置开始将eles中的所有元素添加进来
        List list1 = new ArrayList();
        list1.add("林黛玉");
        list1.add("孙悟空");
        list.addAll(1, list1);
        System.out.println(list); //[Tom, 林黛玉, 孙悟空, Jack, Jerry, Jack]

        //3.Object get ( int index )
        //获取指定index位置的元素
        System.out.println(list.get(1)); //林黛玉

        //4.int indexOf ( Object obj )
        //返回obj在集合中首次出现的位置
        System.out.println(list.indexOf("Jack")); //3
        System.out.println(list.indexOf("林黛玉")); //1
        System.out.println(list.indexOf("贾宝玉")); //-1

        //5.int lastIndexOf ( Object obj )
        //返回obj在当前集合中末次出现的位置
        System.out.println(list.lastIndexOf("Jack")); //5
        System.out.println(list.lastIndexOf("林黛玉")); //1
        System.out.println(list.lastIndexOf("贾宝玉")); //-1

        //6.Object remove ( int index )
        //移除指定index位置的元素,并返回此元素
        list.remove(0);
        System.out.println(list); //[林黛玉, 孙悟空, Jack, Jerry, Jack]

        //7.Object set ( int index , Object ele )
        //设置指定index位置的元素为ele,相当于是替换
        list.set(1, "贾宝玉");
        System.out.println(list); //[林黛玉, 贾宝玉, Jack, Jerry, Jack]
        //list.set(5, "王熙凤");//IndexOutOfBoundsException
        //下标必须存在,不能在最后的后一个使用set添加元素,可以用add

        //8.List subList ( int fromIndex , int toIndex )
        //返回从fromIndex 到 toIndex 位置的子集合
        //返回的子集合区间左闭右开 [fromIndex,toIndex)
        System.out.println(list.subList(1,3)); //[贾宝玉, Jack]
        
    }
}

List遍历

三种遍历方式:List下所有的实现类都可以用这三种方式遍历元素。

  1. 使用iterator
  2. 使用增强for
  3. 使用普通for

代码:

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

//List遍历
public class ListTraversal {
    public static void main(String[] args) {
        //List下所有的实现类都可以用这三种方式遍历元素
        //List list = new ArrayList();
        //List list = new Vector();
        List list = new LinkedList();
        list.add("Tom");
        list.add("Jerry");
        list.add("Jack");

        //遍历
        //1.迭代器
        System.out.println("=====迭代器=====");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

        //2.增强for循环
        System.out.println("=====增强for=====");
        //list.forEach(System.out::println);
        for (Object object : list) {
            System.out.println(object);
        }

        //3.普通for
        System.out.println("=====普通for=====");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

List实现类-ArrayList

ArrayList注意事项

  1. ArrayList 可以加入null,并且多个。
  2. ArrayList是由数组来实现的。
  3. ArrayList基本等同于Vector,除了 ArrayList是线程不安全(执行效率高),在多线程情况下,不建议使用ArrrayList。

源码:

// ArrayList是线程不安全,源码没有synchronized
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

ArrayList的底层操作机制源码分析(重点、难点)

  1. ArrayList 中维护了一个 Object类型的数组 elementData。

    transient Object[] elementData; // transient 标识瞬间,短暂的,表示该属性不会被序列化,即仅存于调用者的内存中而不会保存在硬盘上持久化
    
  2. 当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData 容量为0,第一次添加,则扩容elementData为10,如需再次扩容,则扩容elementData容量为1.5倍。

  3. 如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍。

测试程序:

import java.util.ArrayList;

//ArrayList的底层操作机制源码分析
public class ArrayListDemo {
    public static void main(String[] args) {
        //源码分析
        //使用无参构造器创建ArrayList对象
        ArrayList list = new ArrayList();

        //使用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);

        for (Object object : list) {
            System.out.println(object);
        }

    }
}

无参构造器源码分析

无参构造器源码分析

有参构造器源码分析

有参构造器源码分析

List实现类-Vector

基本介绍

  1. 定义说明

    public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, Serializable
    
  2. Vector 底层也是一个对象数组,protected Object[] elementData;

  3. Vector 是线程同步的,即线程安全,Vector 类的操作方法带有 synchronized

  4. 在开发中,需要线程同步安全时,考虑使用Vector。

Vector和ArrayList的比较

List实现类 底层结构 版本 线程安全(同步)&&效率 扩容倍数
ArrayList 可变数组 jdk1.2 不安全,效率高 如果有参构造1.5倍,如果是无参构造:
1.第一次10;
2.从第二次开始按1.5倍扩容。
Vector 可变数组 jdk1.0 安全,效率不高 如果是无参,默认10,满后,就按2倍扩容。
如果指定大小,则每次直接按2倍扩容。

源码分析:

import java.util.Vector;

//List实现类–Vector的底层操作机制源码分析
public class VectorDemo {
    public static void main(String[] args) {
        //无参构造器
        Vector vector = new Vector();
        //有参构造器
        Vector vector1 = new Vector(10);
        //1. new Vector()底层
        /*
            无参构造:
            public Vector() {
                this(10);
            }
            有参构造:
            public Vector(int initialCapacity) {
                this(initialCapacity, 0);
            }
         */
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        //2. vector.add()
        /*
            2.1 add方法添加数据到vector集合
            public synchronized boolean add(E e) {
                modCount++;
                ensureCapacityHelper(elementCount + 1);
                elementData[elementCount++] = e;
                return true;
            }
            2.2 确定是否需要扩容,判断条件:  if (minCapacity - elementData.length > 0)
            private void ensureCapacityHelper(int minCapacity) {
                // overflow-conscious code
                if (minCapacity - elementData.length > 0)
                    grow(minCapacity);
            }
         */
        vector.add(100);
        //3.需要扩容的vector 两倍扩容
        // capacityIncrement:指定扩容大小,默认为0
        //扩容算法:int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
        /*
            private void grow(int minCapacity) {
                // overflow-conscious code
                int oldCapacity = elementData.length;
                int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                                 capacityIncrement : oldCapacity);
                if (newCapacity - minCapacity < 0)
                    newCapacity = minCapacity;
                if (newCapacity - MAX_ARRAY_SIZE > 0)
                    newCapacity = hugeCapacity(minCapacity);
                elementData = Arrays.copyOf(elementData, newCapacity);
            }
         */
    }
}

List实现类-LinkedList

基本介绍

  1. LinkedList底层实现了双向链表和双端队列特点。
  2. 可以添加任意元素(元素可以重复),包括null。
  3. 线程不安全,没有实现同步。

LinkedList底层结构

  1. LinkedList底层维护了一个双向链表
  2. LinkedList中维护了两个属性first和last分别指向首节点和尾节点。
  3. 每个节点(Node对象),里面又维护了prev、next、item、三个属性,其中通过prev指向前一个,通过next指向后一个节点。最终实现双向链表。
  4. LinkedList的元素的添加和删除,不是通过数组完成的,相对来说效率较高。

LinkedList底层结构

源码分析:

import java.util.Iterator;
import java.util.LinkedList;

//List实现类-LinkedList的底层操作机制源码分析
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        /*源码1:
            public LinkedList() {
            }
            这时的LinkedList属性 first = null , last =null
         */
        linkedList.add(1);
        /*源码2 执行 添加
            2.1:
            public boolean add(E e) {
                linkLast(e);
                return true;
            }
            2.2:  将新的节点加入到双向链表中,尾插法
            void linkLast(E e) {
                final Node<E> l = last;
                final Node<E> newNode = new Node<>(l, e
                last = newNode;
                if (l == null)
                    first = newNode;
                else
                    l.next = newNode;
                size++;
                modCount++;
            }
         */
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList:"+linkedList);

        //删除节点,默认删除首节点
        linkedList.remove();
        /* 3.源码 :删除
            3.1 默认删除第一个 队列特征,先进先出
            public E remove() {
                return removeFirst();
            }
            3.2 当first对象为空时,抛出异常
            public E removeFirst() {
                final Node<E> f = first;
                if (f == null)
                    throw new NoSuchElementException();
                return unlinkFirst(f);
            }
            3.3 将f指向的双向链表的第一个结点拿掉
            private E unlinkFirst(Node<E> f) {
                // assert f == first && f != null;
                final E element = f.item;
                final Node<E> next = f.next;
                f.item = null;
                f.next = null; // help GC 帮助垃圾回收
                first = next;
                if (next == null)
                    last = null;
                else
                    next.prev = null;
                size--;
                modCount++;
                return element;
            }
         */
        System.out.println("linkedList:"+linkedList);


        //修改某个节点对象
        Object set = linkedList.set(0, 666);
        System.out.println(set);
        System.out.println("linklist:"+linkedList);
        /* 4. 修改源码
           4.1 判断 获取 修改 返回旧值
           public E set(int index, E element) {
                checkElementIndex(index);
                Node<E> x = node(index);
                E oldVal = x.item;
                x.item = element;
                return oldVal;
            }
            4.2 判断index是否合法
            private void checkElementIndex(int index) {
                if (!isElementIndex(index))
                    throw new IndexOutOfBoundsException
            }
            4.3 获取索引对应的对象
                如果索引值小于size的一半,从头开始查找,否则从尾开始查找
            Node<E> node(int index) {
                // assert isElementIndex(index);
                if (index < (size >> 1)) {
                    Node<E> x = first;
                    for (int i = 0; i < index; i++)
                        x = x.next;
                    return x;
                } else {
                    Node<E> x = last;
                    for (int i = size - 1; i > index; i
                        x = x.prev;
                    return x;
                }
            }
         */

        //得到某个节点对象
        //get(1)为第二个对象
        Object o = linkedList.get(1);
        System.out.println(o);
        //LinkedList 实现 List 接口 遍历方式与List一致
        System.out.println("=====linkedList迭代器遍历=====");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }
        System.out.println("=====增强for循环遍历=====");
        for (Object o1 : linkedList) {
            System.out.println(o1);
        }
   
        System.out.println("=====传统for循环=====");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }

    }
}

ArrayList和LinkedList比较

List实现类 底层结构 增删效率 改查效率
ArrayList 可变数组 较低,数组扩容 较高
LinkedList 双向链表 较高,通过链表追加 较低

如何选择ArrayList和LinkedList:

  1. 如果改查的操作较多,选择ArrayList。
  2. 如果增删的操作较多,选择LinkedList。
  3. 一般来说,程序中,80%-90%都是查询,因此大部分情况下选择ArrayList。
  4. 在一个项目中,根据业务灵活选择,也可以这样,一个模块使用的是ArrayList,另外一个模块是LinkedList。根据业务合理选择。

标签:10,Java,ArrayList,List,System,add,println,out
From: https://www.cnblogs.com/spicy-hot-pot/p/18447298

相关文章

  • 24.10题目总结
    qoj8328不会证复杂度qoj8049不会证正确性cf2007D根节点和叶子结点的颜色确定10和01的个数差cf1781F转化:)(-->[x-1,x],()-->[x+1,x]然后dp表示执行i次操作,初始前缀和为x的方案数,转移即可cf1396C模拟题cf2006B对于每条路径求出在第几个事件后所有路径上的边的权值被确定......
  • CSP-S模拟赛20241004
    A你考虑可以把这个数组当中的每个数表示成另一种形式:\(a_i=k_i\timesx+b\)(其中\(x\)是模数,\(b\)为余数)。对于求两个数是否对于某个余数同余,显然你要判断他们两个的差,即\(a_i-a_j\),那么我们用上面那种形式表示其实就是\(a_i-a_j=(k_i-k_j)\timesx\),所以你要判断整个数......
  • [lnsyoj2378/luoguAT_arc107_d]Number of Multisets
    题意给出两个正整数\(N,K\),求有多少有理数集满足以下所有条件集合有且只有\(N\)个元素,并且元素和为\(K\);每个元素须可表示为\( \frac{1}{2^{i}}\) $(i\inN)$.sol考虑dp,容易想到记\(f_{i,j}\)表示选\(i\)个数恰好和为\(j\)考虑到会出现诸如\(\dfrac{1}......
  • 2024.10.4 ROS第五章结束,复习背包问题模型 + codeforces刷刷题
    项目学习总结ROS第五章主要是学习了坐标变换,实际用途还是好理解的,比方说地面基地控制无人机追鸟。坐标变换主要是用tf这个包实现的。可以实现静态坐标变换,动态坐标变换和多坐标变换。静态和动态变换的关键函数:ps_out=buffer.transform(ps,"base_link");动态变换里面主要是......
  • 20241004-顺路
    约莫六点一刻时我和lzm吃完晚饭从食堂出来,我想回机房,他说想去找zyx,我惊讶,并说这又不顺路干嘛去找?但是他执意要找,并表示「在我心里是顺路的」,我便和他一起顺路。来到24班后门门口,lzm探头张望,又马上折回来小声对我说些话,我没听清,只听到什么「跟zyx大声说lzm来找她了」,我......
  • YOLOv10/8算法改进【NO.139】借鉴RCS-YOLO算法改进
     前  言    YOLO算法改进系列出到这,很多朋友问改进如何选择是最佳的,下面我就根据个人多年的写作发文章以及指导发文章的经验来看,按照优先顺序进行排序讲解YOLO算法改进方法的顺序选择。具体有需求的同学可以私信我沟通:首推,是将两种最新推出算法的模块进行融合形成......
  • Python常见面试题(100道)
        面试总是让人倍感压力,尤其是在技术领域,准备充分非常关键。为了帮助你更好地应对Python面试,我精心整理了100道经典的Python面试题,并附上详细答案和解析。这些问题涵盖了基础知识、实用技巧和常见难点,旨在提升你的面试能力,让你自信面对挑战。快来领取这份资源,助你顺......
  • 【做题纪要】10月“我想要太多太多装满房子,欢乐自由每刻每时” -- 《我想要太多太多
    P6717[CCO2018]BoringLectures问题相当于求两个距离不大于\(k\)的数对的和的最大值我们把修改改为先删除再进行插入的操作,对于插入操作我们使用线段树在左端点维护每个区间的答案维护区间最大的最大值+次大值,区间最值即可更新答案。咋删?不好删,那么就不删,直接离线然后线......
  • Cornell cs3110 - Chapter6 Exercises
    (*Exercise:specgame*)(*Whereisanotherprogrammer?*)(*Exercise:polyspec*)(*[Poly]representsimmutablepolynomialswithintegercoeffcients*)moduletypePoly=sig(*[t]isthetypeofpolynomials*)typet(*[evalxp]is[p]e......
  • 10月3日总结
    今天起了个早,感觉不错,早起的那一会功夫你可能觉得很艰难,但是实际上你起来之后,去简单的吃个早饭,然后简单的学习一下,然后保持着一种思考的能力,这样我感觉是很舒服的感觉,今天简单的学习了JDBC的相关的东西,了解了JDBC的一些API及其作用我发现这是一种很抽象的东西,在黑马程序员上学......