第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); } } }
异常的出现:
exception in thread "main" java.util.concurrentmodificationexception
如果换为
for(integer integer : arraylist){ system.out.println(arraylist.remove(0)); }
那么显示台为:
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(); } }
在集合初始化时,要尽量指定集合的初始值大小,在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
是基于实现动态数据的数据结构哦,进行随机访问比较容易,用get
和set
方法~
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
是基于链表的数据结构哦~
总结linkedlist
和arraylist
arraylist
比较好访问get
和set
,而linkedlist
比较好增加和删除add
和remove
.都是为了防止移动数据嘛,移动就会比较麻烦嘛~
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); }
package day1; public class demo { public static object[] objects = {}; public static void main(string[] args) throws exception{ system.out.println(objects.getclass()); } }
package day1; public class demo { public static object[] objects = {}; public static void main(string[] args) throws exception{ system.out.println((object)objects.getclass()); } }
不变:
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); } }
string
类可以用于比较字符串,搜索字符串,提取字符串等等,各种方法,字符串的连接可以用+
这个运算符,但是java
提供了stringbuilder
和stringbuffer
类,通过用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()
方法是将数据添加到指定的位置.
案例:
比如在字符缓冲区中已经有对象dashu
用a
进行表示,然后调用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 点赞
上一篇: 企业培训机构做新媒体营销需要注意些什么?
下一篇: jQuery 名称发生冲突怎么办【问题】
推荐阅读
-
基准测试了 ArrayList 和 LinkedList ,发现我们一直用 ArrayList 也是没什么问题的
-
ArrayList和LinkedList区别(蚂蚁金服面试题)
-
Java自学-集合框架 ArrayList和LinkedList的区别
-
Java开发笔记(六十七)清单:ArrayList和LinkedList
-
ArrayList和LinkedList学习
-
第56节:ArrayList,LinkedList和String
-
ArrayList和LinkedList、Vector的优缺点?
-
ArrayList和LinkedList内部的实现大致是怎样的?他们之间的区别和各自适应的场景是什么?
-
集合中ArrayList和LinkedList比较
-
集合中ArrayList和LinkedList比较