经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » Java » 查看文章
第56节:ArrayList,LinkedList和String
来源:cnblogs  作者:达叔小生  时间:2018/10/16 9:40:38  对本文有异议

标题图

  1. import java.util.ArrayList;
  2. public class Demo{
  3. public static void main(String[] args) throws Exception {
  4. ArrayList<Integer> arrayList = new ArrayList<>();
  5. arrayList.add(1);
  6. arrayList.add(2);
  7. arrayList.add(3);
  8. for(Integer integer : arrayList){
  9. arrayList.remove(1);
  10. }
  11. }
  12. }

异常的出现:

描述

  1. Exception in thread "main" java.util.ConcurrentModificationException

如果换为

  1. for(Integer integer : arrayList){
  2. System.out.println(arrayList.remove(0));
  3. }

那么显示台为:

描述

  1. 1
  2. Exception in thread "main" java.util.ConcurrentModificationException

这样的话把 arrayList.remove( ) 中的数字改为 0, 1, 2, 的话,显示台会出现 1, 2, 3, 的.

  1. import java.util.ArrayList;
  2. public class Demo {
  3. public static void main(String[] args) throws Exception{
  4. ArrayList<Integer> arrayList = new ArrayList<>();
  5. arrayList.add(1);
  6. arrayList.add(2);
  7. arrayList.add(3);
  8. for(Integer integer : arrayList){
  9. System.out.println(arrayList.remove(0));
  10. break;
  11. }
  12. }
  13. }

这样控制台显示为:

  1. // 显示为 1
  2. 1

集合是用来存储一些变量

Collection的一些常见方法:

  1. size()
  2. isEmpty(()
  3. contains(Object)
  4. toArray()
  5. toArray(T[])
  6. add(E)
  7. remove(Object)
  8. containsAll(Collection<?>)
  9. addAll(Collection<? extends E>)
  10. retainAll(Collection<?>)
  11. clear()
  12. stream()

ArrayList

  1. // 源码:
  2. public class ArrayList<E> extends AbstractList<E>
  3. implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  4. // 再次往上走
  5. public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
  6. // 再次往上走
  7. public abstract class AbstractCollection<E> implements Collection<E>

在上述代码中,有可能看到的异常会有所不理解。因为无法在迭代的过程中进行修改,只能读而已。因为是一个临时的储存空间。如果要用可以如下:

  1. import java.util.ArrayList;
  2. import java.util.Iterator;
  3. public class Demo {
  4. public static void main(String[] args) throws Exception{
  5. ArrayList<Integer> arrayList = new ArrayList<>();
  6. arrayList.add(11);
  7. arrayList.add(21);
  8. arrayList.add(31);
  9. // for(Integer integer : arrayList){
  10. // System.out.println(arrayList.remove(0));
  11. // break;
  12. // }
  13. System.out.println(arrayList.size());
  14. for (int i = 0,length = arrayList.size(); i <length ; i++) {
  15. System.out.println(i);
  16. arrayList.remove(0);
  17. }
  18. System.out.println(arrayList.size());
  19. }
  20. }
  1. public class Demo {
  2. Object[] object2;
  3. public static Object[] objects = {};
  4. public void test(){
  5. System.out.println(objects == object2);
  6. }
  7. public static void main(String[] args) throws Exception{
  8. Demo n = new Demo();
  9. System.out.println(n.object2);
  10. System.out.println(objects);
  11. new Demo().test();
  12. }
  13. }

描述

在集合初始化时,要尽量指定集合的初始值大小,在ArrayList中,要多多使用ArrayList(int initialCapacity)的初始化.

ArrayList中的内存地址是连续的,它存放的是连续的,如1,2,3,4,5等,可以通过索引找到自己想要,因为是连续的,所以马上就可以找到自己想要的了.

LinkedList中是处于不同的内存地址的,每个元素存储的空间有个文件指针是指向下一个元素的,只有当它进行迭代后,才能找到.

Class ArrayList<E>

java.lang.Object
->java.util.AbstractCollection<E>
->java.util.AbstractList<E>
->java.util.ArrayList<E>

所有实现的接口:

Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess

知道的子类:

AttributeList, RoleList, RoleUnresolveList

完整结构:

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

ArrayList是可以调整数组大小,实现List的接口.ArrayList是基于实现动态数据的数据结构哦,进行随机访问比较容易,用getset方法~

描述

Class LinkedList<E>

java.lang.Object
->java.util.AbstractCollection<E>
->java.util.AbstractList<E>
->java.util.AbstractSequentialList<E>
->java.util.LinkedList<E>

参数类型 E 为这个集合中要保持的数据类型.

完整结构:

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

描述

LinkedList 是使用了循环双向链表数据结构,LinkedList链表是由 元素内容,前驱表和后驱表, 一系列表项连接而成的.

链表内是由一个header的表项是作为链表的开始,也同样有链表的结尾.在链表中表项头header的后驱表项就是链表中第一个元素,而表项header的前驱就是链表的最后一个元素.

数组:数组是连续存储的,所以它的索引非常的快,在内存中赋值和修改也很容易.

int[] arr = new int[3];

int[] arr = new int[3] {1,2,3};

int[] arr = {1,2,3,4};

在数组中一定存在着它不好的缺点,因为如果在我们不知道数组的长度情况下会很麻烦,声明数组一定要指定它的长度,如果这个长度太长,就会导致浪费内存,如果过短的情况下又会导致数据溢出的结果.

这时上帝创建了ArrayList的类,使用这个类就必须要进行引用,然后继承接口,在ArrayList对象的大小是可以动态改变的,不像数组那样死板固定化,可以自由扩展和收缩存储的数据.

创建对象:

ArrayList arrayList = new ArrayList();

添加数据等等:

arrayList.add("dashucoding");

LinkedList都是指针指向下一个元素,如果中间有进行删减,那么后面的元素会提前到前面空缺的位置,后面的也一样.所以LinkedList比较麻烦的,LinkedList是基于链表的数据结构哦~

总结LinkedListArrayList

ArrayList比较好访问getset,而LinkedList比较好增加和删除addremove.都是为了防止移动数据嘛,移动就会比较麻烦嘛~

  1. import java.util.LinkedList;
  2. public class Demo{
  3. public static void main(String[] args){
  4. LinkedList<Integer> linkedList = new LinkedList<>();
  5. linkedList.add(1);
  6. }
  7. }
  1. // add方法
  2. public boolean add(E e){
  3. // 插入到最后一位
  4. linkLast(e);
  5. // 返回为true
  6. return true;
  7. }
  1. // 最尾
  2. void linkLast(E e){
  3. // last赋给l, 初始Last为空
  4. final Node<E> l = last;
  5. final Node<E> newNode = new Node<>(1,e,null);
  6. // 更新Last指针指向新的节点
  7. last = newNode;
  8. if(l == null){
  9. // 如果为第一次插入,就将first指针指向第一个节点
  10. first = newNode;
  11. }else{
  12. // 如果有了头节点,就将l指针的next指向新节点
  13. l.next = newNode;
  14. }
  15. // 链表大小加一
  16. size++;
  17. // 修改次数加一
  18. modCount++;
  19. }
  1. // LinkedList$Node.class 内部类,静态类
  2. private static class Node<E> {
  3. // 数据位
  4. E item;
  5. // 指针
  6. Node<E> next;
  7. Node<E> prev;
  8. // 构造器
  9. Node(Node<E> prev, E element, Node<E> next){
  10. this.item = element;
  11. this.next = next;
  12. this.prev = prev;
  13. }
  14. }
  15. // since 1.6
  16. public Iterator<E> descendingIterator(){
  17. return new DescendingIterator();
  18. }
  1. transient Node<E> last;
  1. public int size(){
  2. return size;
  3. }

ArrayList<E>

  1. public ArrayList() {
  2. this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  3. }
  4. // 构造一个空的对象数组
  5. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  6. // 调用方法
  7. ensureCapacityInternal(size+1);
  8. // list内部日期是否有多余空间
  1. if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){
  2. minCapacity=Math.max(DEFAULT_CAPACITY,minCapacity);
  3. }
  4. ensureExplicitCapacity(minCapacity);
  5. // 记录下数据的修改次数
  6. modCount++;
  7. if(minCapacity - elementData.length > 0)
  8. grow(minCapacity);
  1. private void grow(int minCapacity){
  2. int oldCapacity = elementData.length;
  3. int newCapacity = oldCapacity + (oldCapacity >> 1);
  4. if(newCapacity - minCapacity < 0)
  5. newCapacity = minCapacity;
  6. if(newCapacity - MAX_ARRAY_SIZE > 0)
  7. newCapacity = hugeCapacity(minCapacity);
  8. elementData = Arrays.copyOf(elementData,newCapacity);
  9. }

描述

描述

描述

描述

  1. package day1;
  2. public class Demo {
  3. public static Object[] objects = {};
  4. public static void main(String[] args) throws Exception{
  5. System.out.println(objects.getClass());
  6. }
  7. }

描述

  1. package day1;
  2. public class Demo {
  3. public static Object[] objects = {};
  4. public static void main(String[] args) throws Exception{
  5. System.out.println((Object)objects.getClass());
  6. }
  7. }

不变:

描述

  1. public class Demo {
  2. public static Object[] objects = {};
  3. public static void main(String[] args) throws Exception {
  4. System.out.println((Object)objects == (Object)objects.getClass());
  5. }
  6. }
  7. // false
  1. public class Demo {
  2. public static Object[] objects = {};
  3. public static void main(String[] args) throws Exception{
  4. System.out.println((Object)objects == (Object)Object[].class);
  5. }
  6. }
  7. // false
  1. package day1;
  2. public class Demo {
  3. String string = "dashucoding";
  4. public static void main(String[] args) throws Exception{
  5. String string = "dashucoding";
  6. System.out.println(string.getClass()==String.class);
  7. }
  8. }
  9. // 为true
  1. public static Object[] objects = {};
  2. objects.getClass() == Object[].class
  3. objects instanceof Object[]

String

Class String

java.lang.Object
java.lang.String

public final class String extends Object implement Serializable, Comparable<String>, CharSequece

String类表示为字符串,所有的字符串都被实现为此类的实例,字符串是不可以变的,它们的值在创建后不可以改变,字符串缓冲区是支持可变的字符串的.

字符串:

  1. String str = "dashucoding";

等于:

  1. char data[] = { 'da', 'shu', 'coding'};
  2. String str = new String (data);

例子:

  1. public class Demo {
  2. public static void main(String[] args) throws Exception{
  3. System.out.println("cat");
  4. // cat
  5. String a = "mouse";
  6. System.out.println("cat" + " " + a);
  7. // cat mouse
  8. String c = "cat".substring(2,3);
  9. System.out.println(c);
  10. // s
  11. String d = a.substring(1, 2);
  12. // o
  13. System.out.println(d);
  14. }
  15. }

描述

String类可以用于比较字符串,搜索字符串,提取字符串等等,各种方法,字符串的连接可以用+这个运算符,但是Java提供了StringBuilderStringBuffer类,通过用append方法实现连接,字符串方法还可以用toString的方法进行字符串的转换.

抛出异常:如果字符串传值为null的时候,会抛出NullPointerException.

public String toString()

toString用来返回对象的字符串表现形式

Class StringBuffer

java.lang.Object
java.lang.StringBuffer

public final class StringBuffer extends Object implements Serializable, CharSequence

StringBuffer线程安全,是可变的字符序列,字符串在缓冲区中可以修改,在StringBuffer中是常常用到append方法和insert的方法.通过这些方法进行将数据转换为字符串,把字符串加载到字符串缓冲区中.

append()的方法是用于在缓冲区中的末尾添加这些字符,和insert()方法是将数据添加到指定的位置.

案例:

比如在字符缓冲区中已经有对象dashua进行表示,然后调用a.append("coding");,而insert()插入的方法也容易,参数两个,第一个为插入的位置,第二个为插入的数据而已.

注意每个字符串缓冲区是由属于它自己的容量的,如果内部的缓冲区溢出,就会导致自动变大,如果够用,就不会被分析新的.StringBuffer通常用单个线程字符串缓冲区的地方.

Class StringBuilder

java.lang.Object
java.lang.StringBuilder

public final class StringBuilder extends Object implements Serializable, CharSequence

StringBuilder也是一个可变的资产.同样也有append()方法和insert()的方法,有了StringBuilder的出现,StringBuffer都靠边了.但是如果有多线程就不能够安全的使用了,就要改换使用StringBuffer了.

往后余生,唯独有你
简书作者:达叔小生
90后帅气小伙,良好的开发习惯;独立思考的能力;主动并且善于沟通
简书博客: https://www.jianshu.com/u/c785ece603d1

结语

  • 下面我将继续对 其他知识 深入讲解 ,有兴趣可以继续关注
  • 小礼物走一走 or 点赞
 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号