第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后帅气小伙,良好的开发习惯;独立思考的能力;主动并且善于沟通
简书博客: https://www.jianshu.com/u/c785ece603d1
结语
- 下面我将继续对 其他知识 深入讲解 ,有兴趣可以继续关注
- 小礼物走一走 or 点赞
第56节:ArrayList,LinkedList和String的更多相关文章
- ArrayList,LinkedList和String
import java.util.ArrayList; public class Demo{ public static void main(String[] args) throws Excepti ...
- Java集合--ArrayList,LinkedList性能分析
转载请注明出处:http://www.cnblogs.com/skywang12345/p/3308900.html 第1部分 List概括 先回顾一下List的框架图 (01) List 是一个接口 ...
- ArrayList LinkedList Vector
ArrayList是基于数组实现的,没有容量的限制. 在删除元素的时候,并不会减少数组的容量大小,可以调用ArrayList的trimeToSize()来缩小数组的容量. ArrayList, Lin ...
- ArrayList, LinkedList, Vector - dudu:史上最详解
ArrayList, LinkedList, Vector - dudu:史上最详解 我们来比较一下ArrayList, LinkedLIst和Vector它们之间的区别.BZ的JDK版本是1.7.0 ...
- Hashtable,HashMap,TreeMap有什么区别?Vector,ArrayList,LinkedList有什么区别?int和Integer有什么区别?
接着上篇继续更新. /*请尊重作者劳动成果,转载请标明原文链接:*/ /*https://www.cnblogs.com/jpcflyer/p/10759447.html* / 题目一:Hashtab ...
- 09 Collection,Iterator,List,listIterator,Vector,ArrayList,LinkedList,泛型,增强for,可变参数,HashSet,LinkedHashSet,TreeSet
09 Collection,Iterator,List,listIterator,Vector,ArrayList,LinkedList,泛型,增强for,可变参数,HashSet,LinkedHas ...
- ArrayList,LinkedList的对比
ArrayList,LinkedList都是Collection接口的通用实现方式,两者采用了不用的存储策略,用来适应不同场合的需要. 实现方式 ArrayList的内部采用集合的方式存储数据 唯一需 ...
- Vector & ArrayList Hashtable & HashMap ArrayList & LinkedList
1. Vector & ArrayList 1) Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe),而ArrayList的方法不是,由于线程的 ...
- java面试题(杨晓峰)---第八讲谈谈Vector,ArrayList,LinkedList有何区别?
Vector,ArrayList,LinkedList均为线性的数据结构,但是从现实方式与应用场景中又存在差别. 1 底层实现方式 ArrayList内部数组来实现,LinkedList内部采用双向链 ...
随机推荐
- .NET、JAVA和PHP在Web开发的优缺点
现在做Web开发,用哪个平台哪种语言其实本质上没有太大的区别,因为Web开发框架已经非常成熟,只要符合需求,能按时交付产品就ok了. 要选择哪个平台,是个商业问题,不是技术问题. 选择任何的语言最好深 ...
- filter 全局和局部过滤器
1,局部过滤器 2,全局过滤器 使用方法相同,在花括号中使用过滤器名或者v-bind中使用
- 跨域的处理方式 JSONP和CORS和反向代理
什么是跨域? 首先了解同源策略,三个相同,协议,域名端口号相同就是同源,那么三者有任意不同就会造成跨域.跨域不常见,跨域基本上就是访问别人的资源. 如何解决跨域问题? 常见的有三种 一:jsonp处理 ...
- Eclispe 错误:找不到或无法加载加载主类
解决办法: Project --> Clean Clean 操作会将该 project 以前的所有编译信息清空,然后默认将所有工程的所有 .java 文件都进行一次编译,这样的话就可以方便的进行 ...
- IDEA debugger模式下启动慢
很可能是因为代码里面有端点造成的. 点击如下图的重叠红点,找到对应端点点掉就可以了.
- 密码与安全新技术专题之WEB应用安全
学号 2018-2019-2 <密码与安全新技术专题>第1周作业 课程:<密码与安全新技术专题> 班级: 1892 姓名: 李熹桥 学号:20189214 上课教师:谢四江 上 ...
- 你电梯没了—OO第二单元作业思考
写在前面 这三次电梯调度作业,主要是学习多线程并行操作,对于各个线程的时间轴的把握,互相的配合与影响,通过使用锁来解决访问冲突等方面. 个人在学会Thread相关操作之外,写出来一些奇怪结构的诡异操作 ...
- XBee模块户外通信距离测试
Digi的XBee模块在市面上同类产品中,除了稳定性和可靠性最受推崇外,在距离测试中一般都比竞争对手的产品略胜一筹.户外测试需要注意避免模块自身以外的因素造成的测试结果不理想. 2.4G的模块有Zig ...
- nginx上传文件时 nginx 413 Request Entity Too Large 错误
产生原因: 上传文件的大小超出了 Nginx 允许的最大值,默认是1M: 解决方法: 修改Nginx的配置文件(一般是:nginx/nginx.conf),在 http{} 段中增大nginx上传文件 ...
- ajax相关知识总结
一.原生AJAX的兼容版本实现 function createXhr(){ var Xhr = null; //浏览器的判断 if(window.XMLHttpRequest){ //ie789 ch ...