欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

第56节:ArrayList,LinkedList和String

程序员文章站 2022-08-17 15:14:17
异常的出现: 如果换为 那么显示台为: 这样的话把 中的数字改为 0, 1, 2, 的话,显示台会出现 1, 2, 3, 的. 这样控制台显示为: 集合是用来存储一些变量 的一些常见方法: 在上述代码中,有可能看到的异常会有所不理解。因为无法在迭代的过程中进行修改,只能读而已。因为是一个临时的储存空 ......

第56节:ArrayList,LinkedList和String

import java.util.arraylist;
public class demo{
 public static void main(string[] args) throws exception {
   arraylist<integer> arraylist = new arraylist<>();
   arraylist.add(1);
   arraylist.add(2);
   arraylist.add(3);
   for(integer integer : arraylist){
    arraylist.remove(1);
   }
 }
}

异常的出现:

第56节:ArrayList,LinkedList和String

exception in thread "main" java.util.concurrentmodificationexception

如果换为

for(integer integer : arraylist){
 system.out.println(arraylist.remove(0));
}

那么显示台为:

第56节:ArrayList,LinkedList和String

1
exception in thread "main" java.util.concurrentmodificationexception

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

import java.util.arraylist;
public class demo {
    public static void main(string[] args) throws exception{
        arraylist<integer> arraylist = new arraylist<>();
        arraylist.add(1);
        arraylist.add(2);
        arraylist.add(3);
        for(integer integer : arraylist){
           system.out.println(arraylist.remove(0));
           break;
        }
    }
}

这样控制台显示为:

// 显示为 1
1

集合是用来存储一些变量

collection的一些常见方法:

size()
isempty(()
contains(object)
toarray()
toarray(t[])
add(e)
remove(object)
containsall(collection<?>)
addall(collection<? extends e>)
retainall(collection<?>)
clear()
stream()

arraylist

// 源码:
public class arraylist<e> extends abstractlist<e>
implements list<e>, randomaccess, cloneable, java.io.serializable
// 再次往上走
public abstract class abstractlist<e> extends abstractcollection<e> implements list<e>
// 再次往上走
public abstract class abstractcollection<e> implements collection<e>

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

import java.util.arraylist;
import java.util.iterator;
public class demo {
    public static void main(string[] args) throws exception{
        arraylist<integer> arraylist = new arraylist<>();
        arraylist.add(11);
        arraylist.add(21);
        arraylist.add(31);
//      for(integer integer : arraylist){
//         system.out.println(arraylist.remove(0));
//         break;
//      }
        
        system.out.println(arraylist.size());
        for (int i = 0,length = arraylist.size(); i <length ; i++) {
            system.out.println(i);
            arraylist.remove(0);
        }
        system.out.println(arraylist.size());
    }
}
public class demo {
     object[] object2;
     public static object[] objects = {};
     public void test(){
      system.out.println(objects == object2);
     }
    public static void main(string[] args) throws exception{
        demo n = new demo();
        system.out.println(n.object2);
        system.out.println(objects);
        new demo().test();
    }
}

第56节:ArrayList,LinkedList和String

在集合初始化时,要尽量指定集合的初始值大小,在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方法~

第56节:ArrayList,LinkedList和String

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

第56节:ArrayList,LinkedList和String

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.都是为了防止移动数据嘛,移动就会比较麻烦嘛~

import java.util.linkedlist;
public class demo{
 public static void main(string[] args){
  linkedlist<integer> linkedlist = new linkedlist<>();
  linkedlist.add(1);
 }
}
// add方法
public boolean add(e e){
 // 插入到最后一位
 linklast(e);
 // 返回为true
 return true;
}
// 最尾
void linklast(e e){
 // last赋给l, 初始last为空
 final node<e> l = last;
 final node<e> newnode = new node<>(1,e,null);
 // 更新last指针指向新的节点
 last = newnode;
 if(l == null){
  // 如果为第一次插入,就将first指针指向第一个节点
  first = newnode;
 }else{
  // 如果有了头节点,就将l指针的next指向新节点
  l.next = newnode;
 }
 // 链表大小加一
 size++;
 // 修改次数加一
 modcount++;
}
// linkedlist$node.class 内部类,静态类
private static class node<e> {
 // 数据位
 e item;
 // 指针
 node<e> next;
 node<e> prev;
 // 构造器
 node(node<e> prev, e element, node<e> next){
  this.item = element;
  this.next = next;
  this.prev = prev;
 }
}
// since 1.6
public iterator<e> descendingiterator(){
 return new descendingiterator();
}
transient node<e> last;
public int size(){
 return size;
}

arraylist<e>

public arraylist() {
 this.elementdata = defaultcapacity_empty_elementdata;
}
// 构造一个空的对象数组
private static final object[] defaultcapacity_empty_elementdata = {};
// 调用方法
ensurecapacityinternal(size+1);
// list内部日期是否有多余空间
if(elementdata == defaultcapacity_empty_elementdata){
 mincapacity=math.max(default_capacity,mincapacity);
}
ensureexplicitcapacity(mincapacity);
// 记录下数据的修改次数
modcount++;
if(mincapacity - elementdata.length > 0)
grow(mincapacity);
private void grow(int mincapacity){
 int oldcapacity = elementdata.length;
 int newcapacity = oldcapacity + (oldcapacity >> 1);
 if(newcapacity - mincapacity < 0)
  newcapacity = mincapacity;
 if(newcapacity - max_array_size > 0)
  newcapacity = hugecapacity(mincapacity);
 elementdata = arrays.copyof(elementdata,newcapacity);
}

第56节:ArrayList,LinkedList和String

第56节:ArrayList,LinkedList和String

第56节:ArrayList,LinkedList和String

第56节:ArrayList,LinkedList和String

package day1;
public class demo {
    public static object[] objects = {};
    public static void main(string[] args) throws exception{
        system.out.println(objects.getclass());
    }
}

第56节:ArrayList,LinkedList和String

package day1;
public class demo {
    public static object[] objects = {};
    public static void main(string[] args) throws exception{
        system.out.println((object)objects.getclass());
    }
}

不变:

第56节:ArrayList,LinkedList和String

public class demo {
    public static object[] objects = {};
    public static void main(string[] args) throws exception {
        system.out.println((object)objects == (object)objects.getclass());
    }
}
// false
public class demo {
    public static object[] objects = {};
    public static void main(string[] args) throws exception{
        system.out.println((object)objects == (object)object[].class);
    }
}
// false
package day1;
public class demo {
    string string = "dashucoding";
    public static void main(string[] args) throws exception{
     string string = "dashucoding";
     system.out.println(string.getclass()==string.class);
    }
}
// 为true
public static object[] objects = {};
objects.getclass() == object[].class
objects instanceof object[]

string

class string

java.lang.object
java.lang.string

public final class string extends object implement serializable, comparable<string>, charsequece

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

字符串:

string str = "dashucoding";

等于:

char data[] = { 'da', 'shu', 'coding'};
string str = new string (data);

例子:

public class demo {
    public static void main(string[] args) throws exception{
        system.out.println("cat");
        // cat
        string a = "mouse";
        system.out.println("cat" + " " + a);
        // cat mouse
        string c = "cat".substring(2,3);
        system.out.println(c);
        // s
        string d = a.substring(1, 2);
        // o
        system.out.println(d);
    }
}

第56节:ArrayList,LinkedList和String

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后帅气小伙,良好的开发习惯;独立思考的能力;主动并且善于沟通
简书博客:

结语

  • 下面我将继续对 其他知识 深入讲解 ,有兴趣可以继续关注
  • 小礼物走一走 or 点赞