1、首先从测试代码开始：

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0;i<6000;i++){
            list.add(i);
        }
        List<Integer> list1 = list.subList(0,3000);
        List<Integer> list2 = list.subList(3000,6000);
        list2.clear();
        System.out.println("list1 = " + list1);

    }
}


首先初始化一个6000个元素的list，然后，利用list.subList()截取3000个元素到list1中，再取出后3000个元素到list2中，然后清空list2，最后再打印list1,此时将抛出异常：



2、前戏知识：

subList()方法原理分析：

上面的测试方式为什么会出现这个情况，看上去明明没有任何问题，但是打印list1的时候就抛出异常，肯定不可能是System.out.println()有bug吧，再来仔细看看代码，似乎只有打印语句前面几句话会出现问题，那么就是subList()的调用以及clear()这几句代码了，那么问题到底出现在哪里，我们来一探究竟;

接下来我们首先看一下ArrayList中对subList()方法的实现的源码，看它究竟干了些什么事儿：



在subList()方法的源码中首先调用了 subListRangeCheck(fromIndex, toIndex, size) 这个方法主要作用就是判断subList()传入的参数是否合规，这里不是重点，重点在于它  return new SubList(this, 0, fromIndex, toIndex)，返回了一个SubList对象，继续往下看一下这个SubList对象，源码在1010行：



通过源码可以看到，这个SubList对象是一个内部类，

2.1、在构造对象时，会传入4个参数：

AbstractList<E> parent：当前调用subList()方法的list对象

int offset：偏移量（从0开始）

int fromIndex：开始下标（包含）

int toIndex：结束下标（不包含）

2.2、在构造器内部：

将传入的parent赋给SubList对象的成员变量parent；

fromIndex赋给SubList对象的成员变量parentOffset；

offset+fromIndex赋给SubList对象的成员变量offset，用于记录元素的偏移量；

toIndex - fromIndex赋给SubList对象的成员变量size，用于记录此时会返回的数据量大小；

最后一个是 ArrayList.this.modCount 赋给SubList对象的成员变量modCount ，这个赋值比较关键，记录了修改过的次数，默认为0；

到这里，构造一个SubList对象就完成了，你可能会有疑问，只是单纯的构造了一个SubList对象，那么是怎么进行赋值取值的；解决这个问题，来看一下SubList对象的get（）方法：



在get()方法中，最终返回的是 ArrayList.this.elementData(offset + index);可以看到，它是从当前的ArrayList对象中维护的一个elementData（）方法中取值，再来看elementData（）这个方法：



返回的是elementData这个数组中的元素：

由此可见：SubList对象中操作的集合与原始list中操作的集合是同一个集合，通过offset偏移量加上index来标记元素的位置；所以，当你操作原始list或者截取元素后生成的list1集合，都是影响同一个集合。

3、高潮部分：

异常产生分析：

有了上面第二步的分析，有了一个基本认识，那就是list.subList()方法返回的集合会直接影响原始的list集合，接下来继续分析java.util.ConcurrentModificationException异常出现的原因；

再次回到测试代码的以下四句代码：

List<Integer> list1 = list.subList(0,3000);
List<Integer> list2 = list.subList(3000,6000);
list2.clear();
System.out.println("list1 = " + list1);

首先通过  List<Integer> list1 = list.subList(0,3000); 等到一个list1; 

然后再次通过  List<Integer> list2= list.subList(3000,6000); 等到一个list2; 

然后清空list2 即list2.clear();

最后打印：System.out.println("list1 = " + list1);

由于上面分析我们知道，list2调用clear()方法，那么此时原始list维护的底层elementData数组势必会受影响，具体就是会把这后面3000个元素给删除掉，此时list1再去打印，它会调用自己重写的迭代方法iterator()进行遍历，然后调用父级AbstractList的listIterator()方法，由于SubList类继承了AbstractList 所以它会来调用SubList类的listIterator(final int index)方法，此时该方法内部在第一句就调用了checkForComodification();这个方法：



 

接下来看 checkForComodification()这个方法在干什么：



重点来了，这个方法里面首先判断了 ArrayList.this.modCount 与 this.modCount（即SubList的modCount）是否相同，如果不相同则抛出异常java.util.ConcurrentModificationException，写得累死我了，绕了一大圈终于写到这个异常了，在生成list1时，它在实例化一个SubList对象时将原始list的modCount赋值给了SubList对象，此时是默认值0，当list2.clear()时，原始list的modCount已经发生了变化，即不再是0，所以 此时打印list1时，checkForComodification()方法中的ArrayList.this.modCount != this.modCount判断肯定时true,所以这就是异常抛出的原因。

4、附上一位研究了subList()方法上面的注释得出的结论的图供大家参考学习：



 

一、异常的抛出
1、定义 ： 一个方法不处理这个异常，而是调用层次向上传递，谁调用这个方法，这个异常就由谁来处理。
2、throw :  将产生的异常抛出(强调的是动作)，抛出的既可以是异常的引用，也可以是异常对象。（位置: 方法体内）
3、throws : 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常（可以是一种类型，也可以是多种类型，用逗号隔开）（位置:  写在方法名 或方法名列表之后 ，在方法体之前。）
注意 ： 调用可能会抛出异常的方法，必须添加try-catch代码块尝试去捕获异常 或者 添加throws 声明 来将异常 抛出给更上一层的调用者进行处理,这里需要注意一个细节:新的异常包含原始异常的所有信息，根据这个我们可以去追溯最初异常发生的位置，
如下图所示

4、简单使用
// 定义一个方法,抛出 数组越界和算术异常（多个异常 用 "," 隔开）
	public void Test1(int x) throws ArrayIndexOutOfBoundsException,ArithmeticException{
	
	System.out.println(x);
	
	if(x == 0){
		
		System.out.println("没有异常");
		return;
	}
	
	//数据越界异常
	else if (x == 1){
		
		int[] a = new int[3];
		 a[3] = 5;
	}
	
	//算术异常
	else if (x == 2){
		
	    int i = 0;
		int j = 5/0;
	}
		
	}

在main方法中调用
public static void main(String[] args) {
		
		//创建对象
		ExceptionInital object = new ExceptionInital();
		
		// 调用会抛出异常的方法，用try-catch块
	    try{
	    	
	    	object.Test1(0);
	    	
	    }catch(Exception e){
	    	
	    	System.out.println(e);
	    }

	    // 数组越界异常
	    try{
	    	
	    	object.Test1(1);
	    }catch (ArrayIndexOutOfBoundsException e) {
			
	    	System.out.println("数组越界异常:"+e);
		}
	    
	    
	    // 算术异常
	    try{
	    	
	    	object.Test1(2);
	    	
	    }catch(ArithmeticException e){
	    	
	    	System.out.println("算术异常:"+e);
	    }
	    
	    
	    //使用 throw 抛出异常(可以抛出异常对象，也可以抛出异常对象的引用)
	    try{
	    	
	        ArrayIndexOutOfBoundsException  exception = new ArrayIndexOutOfBoundsException();
	    	
	    	throw exception;//new ArrayIndexOutOfBoundsException();
	    	
	    }catch(ArrayIndexOutOfBoundsException e){
	    	
	    	System.out.println("thorw抛出异常:"+e);
	    }
	    
	}

运行结果

总结下 throw 和throws 关键字的区别
1、写法上 : throw 在方法体内使用，throws 函数名后或者参数列表后方法体前

2、意义 ： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生

3、throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象，或者异常对象的引用。

4、throws 用户抛出异常，当在当前方法中抛出异常后，当前方法执行结束（throws 后，如果有finally语句的话，会执行到finally语句后再结束。）。可以理解成return一样。
二、自定义异常
前面所讲的异常，都是系统自带的，系统自己处理，但是很多时候项目会出现特有问题，而这些问题并未被java所描述并封装成对象，所以对于这些特有的问题可以按照java的对问题封装的思想，将特有的问题进行自定义异常封装。在Java中要想创建自定义异常，需要继承Throwable或者他的子类Exception。
语法
class  自定义异常类 extends 异常类型(Exception){

 // 因为父类已经把异常信息的操作都完成了，所在子类只要在构造时，将异常信息传递给父类通过super 语句即可。
  // 重写 有参 和 无参  构造方法
}

例如:
public class CustomException extends Exception {

	//无参构造方法
	public CustomException(){
		
		super();
	}
	
	//有参的构造方法
	public CustomException(String message){
		super(message);
		
	}
	
	// 用指定的详细信息和原因构造一个新的异常
	public CustomException(String message, Throwable cause){
		
		super(message,cause);
	}
	
	//用指定原因构造一个新的异常
	 public CustomException(Throwable cause) {
		 
		 super(cause);
	 }
	
}

// 备注： 这些方法怎么来的？ 重写父类Exception的方法，那么如何查看Exception具有哪些API，快捷键：选中Exception, command+单击。windows系统 ：选中Exception, control+单击。

自定义异常的使用例子:

自定义test1()方法，抛出 "我喝酒了"的异常信息，test2()方法调用test1()方法，并将异常包装成RuntimeException类型的异常，继续抛出，在main方法中调用test2()方法，并尝试捕获异常
public void test2() {
		
		try{
			
			test1();
			
		}catch (CustomException e){
			
		   RuntimeException exception  =  new RuntimeException(e);
		   //exception.initCause(cause)
		   throw  exception;
		}
	
	}
	
	public void test1() throws CustomException{
		
		throw new CustomException("我喝酒了");
	}
// main方法
	public static void main(String[] args) {
		
		CustomExceptionInital object =  new  CustomExceptionInital();
		
		//try{
			
			object.test2();
			
		//}catch(Exception e){
			
		//e.printStackTrace();
			
		//}

	}

输出结果:

思考 ？ 为什么上述demo, test1() 方法 抛出异常了，但是test1() 方法自己没办法处理，所以在 参数列表后方法体前将该异常抛出了，test2() 方法调用了test1()方法捕获其异常，并将其异常 包装成 RuntimeException 异常继续抛出，但是test2()方法却没有声明 抛出异常 ？ 而且，在main 方法中，调用test2()方法的时候，也不用try-catch 代码块去捕获 异常呢 ？点击我告诉你为什么
本篇文章demo传送门

分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow
也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！
                这是一篇有关JAVA：内层方法抛出异常，外层方法捕捉并处理异常的文章信息。
我发布到报名在线EDU84.COM上，和大家分享一下JAVA：内层方法抛出异常，外层方法捕捉并处理异常
public void methodA (){ 
try{ 
// 调用methodB 
methodB(); 
} 
catch(ExceptionType et){ 
// 相应处理措施 
} 
} 
public void methodB throws ExceptionType{ 
if (condition is true) 
{ 
// 相应处理措施 
} 
else 
{ 
throw new ExceptionType(argument); 
} 
} 
在这个例子中，方法B的头部中声明了该方法会抛出一个类型为ExceptionType的异常，在方法体中使用throw子句抛出了一个异常，那么该异常被谁捕捉到呢，答案是方法A。因为异常抛出后，JVM会顺着该方法的调用栈一层一层的往上找。因为方法A中有一个catch(ExceptionType et),所以被抛出的异常会被捕捉到并处理。            
给我老师的人工智能教程打call！http://blog.csdn.net/jiangjunshow

你好！ 这是你第一次使用 **Markdown编辑器** 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。
新的改变
我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

全新的界面设计 ，将会带来全新的写作体验；
在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
全新的 KaTeX数学公式 语法；
增加了支持甘特图的mermaid语法 功能；
增加了 多屏幕编辑 Markdown文章功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
增加了 检查列表 功能。

功能快捷键
撤销：Ctrl/Command + Z

重做：Ctrl/Command + Y

加粗：Ctrl/Command + B

斜体：Ctrl/Command + I

标题：Ctrl/Command + Shift + H

无序列表：Ctrl/Command + Shift + U

有序列表：Ctrl/Command + Shift + O

检查列表：Ctrl/Command + Shift + C

插入代码：Ctrl/Command + Shift + K

插入链接：Ctrl/Command + Shift + L

插入图片：Ctrl/Command + Shift + G
合理的创建标题，有助于目录的生成
直接输入1次#，并按下space后，将生成1级标题。

输入2次#，并按下space后，将生成2级标题。

以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。
如何改变文本的样式
强调文本 强调文本
加粗文本 加粗文本
标记文本
删除文本

引用文本

H2O is是液体。
210 运算结果是 1024.
插入链接与图片
链接: link.
图片: 
带尺寸的图片: 
当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。
如何插入一段漂亮的代码片
去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.
// An highlighted block var foo = 'bar'; 
生成一个适合你的列表

项目

项目

项目






项目1
项目2
项目3


 计划任务
 完成任务

创建一个表格
一个简单的表格是这么创建的：




项目
Value




电脑
$1600


手机
$12


导管
$1


设定内容居中、居左、居右
使用:---------:居中

使用:----------居左

使用----------:居右




第一列
第二列
第三列




第一列文本居中
第二列文本居右
第三列文本居左


SmartyPants
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：




TYPE
ASCII
HTML




Single backticks
'Isn't this fun?'
‘Isn’t this fun?’


Quotes
"Isn't this fun?"
“Isn’t this fun?”


Dashes
-- is en-dash, --- is em-dash
– is en-dash, — is em-dash


创建一个自定义列表

Markdown
Text-to-HTML conversion tool
Authors
John
Luke

如何创建一个注脚
一个具有注脚的文本。
注释也是必不可少的
Markdown将文本转换为 HTML。
KaTeX数学公式
您可以使用渲染LaTeX数学表达式 KaTeX:
Gamma公式展示 $\Gamma(n) = (n-1)!\quad\forall
n\in\mathbb N$ 是通过欧拉积分
$\Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,.$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章
gantt
        dateFormat  YYYY-MM-DD
        title Adding GANTT diagram functionality to mermaid
        section 现有任务
        已完成               :done,    des1, 2014-01-06,2014-01-08
        进行中               :active,  des2, 2014-01-09, 3d
        计划一               :         des3, after des2, 5d
        计划二               :         des4, after des3, 5d


关于 甘特图 语法，参考 这儿,

UML 图表
可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：:

这将产生一个流程图。:


关于 Mermaid 语法，参考 这儿,

FLowchart流程图
我们依旧会支持flowchart的流程图：


关于 Flowchart流程图 语法，参考 这儿.

导出与导入
导出
如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。
导入
如果你想加载一篇你写过的.md文件或者.html文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，

继续你的创作。



mermaid语法说明 ↩︎

注脚的解释 ↩︎

目录
一、throws与声明方法抛出异常

一、throws与声明方法抛出异常
在一个方法中如果能够处理异常，则需要捕获并处理。但是本方法没有能力处理该异常，捕获它没有任何意义，则需要在方法后面声明抛出该异常，通知上层调用者该方法有可以发生异常。

代码如下：
import java.io.*;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

//throws与声明方法抛出异常
public class HelloWorld {
    public static void main(String[] args) {
        try {
            Date date = readDate();
            System.out.println(date);

        } catch (ParseException e) {
            System.out.println("处理ParseException");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("处理IOException");
            e.printStackTrace();
        }
    }
//    事实上有三个异常IOException, ParseException, FileNotFoundException。由于FileNotFoundException是属于IOException,异常所以只声明IOException异常即可
    public static Date readDate() throws IOException, ParseException {
//        自动资源管理
        FileInputStream readfile = new FileInputStream("raedme.txt");
        InputStreamReader ir = new InputStreamReader(readfile);
        BufferedReader in  = new BufferedReader(ir);

//        读取文件中的一行数据， 调用BufferedReader输入流的readLine()方法可能会发生IOException异常
        String str = in.readLine();
        if(str == null){
            return null;
        }
//            调用SimpleDateFormat()方法可能会发生ParseException异常
        DateFormat df  = new SimpleDateFormat("yyyy-MM-dd");
        java.util.Date date = df.parse(str);
        return date;
    }
}

如果声明抛出的多个异常类之间有父子关系，可以只声明抛出父类。但如果没有父子关系 情况下，最好明确声明抛出每一个异常，因为上层调用者会根据这些异常信息进行相应的处理。

上述代码有三个异常FileNotFoundException、IOException和 ParseException，由于FileNotFoundException属于IOException异常，所以只声明IOException和 ParseException就可以了。
以上内容仅供参考学习，如有侵权请联系我删除！