标签：Java String int System 笔记语法 println 集合 out

大二学习Java语法时，上课写的部分笔记，可能并不完整，仅用以作纪念。

数组、集合、字符串（第六课）

数组、集合、字符串（第六课）
- String
异常
- 异常处理机制:
输入输出流
- - 输入流
  - 输出流
    - 查看系统默认编码

数组

数组：同类数据的定长集合

一维数组、二维数组

int list[] = {1,2,3}; int len = list.length

集合类

集合：集合存放对象，非基本类型数据

Collection接口：

接口方法

方法名称	说明
boolean add(E e)	向集合中添加一个元素，如果集合对象被添加操作改变了，则返回 true。E 是元素的数据类型
boolean addAll(Collection c)	向集合中添加集合 c 中的所有元素，如果集合对象被添加操作改变了，则返回 true。
void clear()	清除集合中的所有元素，将集合长度变为 0。
boolean contains(Object o)	判断集合中是否存在指定元素
boolean containsAll(Collection c)	判断集合中是否包含集合 c 中的所有元素
boolean isEmpty()	判断集合是否为空
Iteratoriterator()	返回一个 Iterator 对象，用于遍历集合中的元素
boolean remove(Object o)	从集合中删除一个指定元素，当集合中包含了一个或多个元素 o 时，该方法只删除第一个符合条件的元素，该方法将返回 true。
boolean removeAll(Collection c)	从集合中删除所有在集合 c 中出现的元素（相当于把调用该方法的集合减去集合 c）。如果该操作改变了调用该方法的集合，则该方法返回 true。
boolean retainAll(Collection c)	从集合中删除集合 c 里不包含的元素（相当于把调用该方法的集合变成该集合和集合 c 的交集），如果该操作改变了调用该方法的集合，则该方法返回 true。
int size()	返回集合中元素的个数
Object[] toArray()	把集合转换为一个数组，所有的集合元素变成对应的数组元素。

泛型：

class GenericFoo<T>{

}

List：

List接口： public interface List extends Collection

是Collection接口的子接口，列表，有顺序的集合提供的方法：

（部分！！！）E remove (int index)：移除列表中指定位置的元素

int [indexOf]：返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1

Java List集合：ArrayList和LinkedList类的用法及区别 (biancheng.net)

它主要由两个常用的实现类：ArrayList类和LinkedList类：

ArrayList:

ArrayList 类实现了可变数组的大小，存储在内的数据称为元素。它还提供了快速基于索引访问元素的方式，对尾部成员的增加和删除支持较好。缺点：插入与删除速度相对较慢。

方法名称	说明
E get(int index)	获取此集合中指定索引位置的元素，E 为集合中元素的数据类型
int index(Object o)	返回此集合中第一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
int lastIndexOf(Object o)	返回此集合中最后一次出现指定元素的索引，如果此集合不包含该元素，则返回 -1
E set(int index, Eelement)	将此集合中指定索引位置的元素修改为 element 参数指定的对象。此方法返回此集合中指定索引位置的原元素
List subList(int fromlndex, int tolndex)	返回一个新的集合，新集合中包含 fromlndex 和 tolndex 索引之间的所有元素。包含 fromlndex 处的元素，不包含 tolndex 索引处的元素

public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
			list.add(new Integer(6));
			list.add(new Integer(9));
			list.add(new Integer(3));
			list.add(new Integer(5));
			list.add(new Integer(6));
			Iterator<Integer> it = list.iterator();
			while(it.hasNext()){
				System.out.println(it.next());
			}
		}
//这里是是创建的Integer类

//使用演示1
class Product {
    // 商品类
    private int id; // 商品编号
    private String name; // 名称
    private float price; // 价格
    public Product(int id, String name, float price) {
        this.name = name;
        this.id = id;
        this.price = price;
    }
    // 这里是上面3个属性的setter/getter方法，这里省略
    public String toString() {
        return "商品编号：" + id + "，名称：" + name + "，价格：" + price;
    }
}

public class Test {
    public static void main(String[] args) {
        Product pd1 = new Product(4, "木糖醇", 10);
        Product pd2 = new Product(5, "洗发水", 12);
        Product pd3 = new Product(3, "热水壶", 49);
        List list = new ArrayList(); // 创建集合
        //List<Product> list = new ArrayList();一般可能是这样写的
        list.add(pd1);
        list.add(pd2);
        list.add(pd3);
        System.out.println("*************** 商品信息 ***************");
        for (int i = 0; i < list.size(); i++) {
            // 循环遍历集合，输出集合元素
            Product product = (Product) list.get(i);//与 Set 不同的是，List 集合中存在 get() 方法，该方法可以通过索引来获取所对应的值，获取的值为 Object 类，因此需要将该值转换为 Product 类
            System.out.println(product);//因为上面重写了toStirng()
        }
    }
}

//使用演示2 indexOf() lastIndexOf()
public static void main(String[] args) {
    List list = new ArrayList();
    list.add("One");
    list.add("|");
    list.add("Two");
    list.add("|");
    list.add("Three");
    list.add("|");
    list.add("Four");
    System.out.println("list 集合中的元素数量：" + list.size());
    System.out.println("list 集合中的元素如下：");
    Iterator it = list.iterator();//转换成Iterator方便遍历
    while (it.hasNext()) {
        System.out.print(it.next() + "、");
    }
    System.out.println("\n在 list 集合中'丨'第一次出现的位置是：" + list.indexOf("|"));
    System.out.println("在 list 集合中'丨'最后一次出现的位置是：" + list.lastIndexOf("|"));
}
/*
list 集合中的元素数量：7
list 集合中的元素如下：
One、|、Two、|、Three、|、Four、
在 list 集合中'|'第一次出现的位置是：1
在 list 集合中'|'最后一次出现的位置是：5
*/

//subList() 的用法  
List sublist = new ArrayList();
    sublist = list.subList(2, 5); // 从list集合中截取索引2~5的元素，保存到sublist集合中

LinkedList类

LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。

需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高，但是 LinkedList 类随机访问元素的速度则相对较慢。这里的随机访问是指检索集合中特定索引位置的元素。

除Collection接口和List接口的所有方法外，还有的接口

方法名称	说明
void addFirst(E e)	将指定元素添加到此集合的开头
void addLast(E e)	将指定元素添加到此集合的末尾
E getFirst()	返回此集合的第一个元素
E getLast()	返回此集合的最后一个元素
E removeFirst()	删除此集合中的第一个元素
E removeLast()	删除此集合中的最后一个元素

public class Test {
    public static void main(String[] args) {
        LinkedList<String> products = new LinkedList<String>(); // 创建集合对象
        String p1 = new String("六角螺母");
        String p2 = new String("10A 电缆线");
        String p3 = new String("5M 卷尺");
        String p4 = new String("4CM 原木方板");
        products.add(p1); // 将 p1 对象添加到 LinkedList 集合中
        products.add(p2); // 将 p2 对象添加到 LinkedList 集合中
        products.add(p3); // 将 p3 对象添加到 LinkedList 集合中
        products.add(p4); // 将 p4 对象添加到 LinkedList 集合中
        String p5 = new String("标准文件夹小柜");
        products.addLast(p5); // 向集合的末尾添加p5对象
        System.out.print("*************** 商品信息 ***************");
        System.out.println("\n目前商品有：");
        for (int i = 0; i < products.size(); i++) {
            System.out.print(products.get(i) + "\t");
        }
        System.out.println("\n第一个商品的名称为：" + products.getFirst());
        System.out.println("最后一个商品的名称为：" + products.getLast());
        products.removeLast(); // 删除最后一个元素
        System.out.println("删除最后的元素，目前商品有：");
        for (int i = 0; i < products.size(); i++) {
            System.out.print(products.get(i) + "\t");
        }
    }
}
/*
*************** 商品信息 ***************
目前商品有：
六角螺母    10A 电缆线    5M 卷尺    4CM 原木方板    标准文件夹小柜   
第一个商品的名称为：六角螺母
最后一个商品的名称为：标准文件夹小柜
删除最后的元素，目前商品有：
六角螺母    10A 电缆线    5M 卷尺    4CM 原木方板
*/

LinkedList 中的是 Java 中的泛型，用于指定集合中元素的数据类型，例如这里指定元素类型为 String，则该集合中不能添加非 String 类型的元素。

ArrayList 类和 LinkedList 类的区别

ArrayList 与 LinkedList 都是 List 接口的实现类，因此都实现了 List 的所有未实现的方法，只是实现的方式有所不同。

ArrayList 是基于动态数组数据结构的实现，访问元素速度优于 LinkedList。LinkedList 是基于链表数据结构的实现，占用的内存空间比较大，但在批量插入或删除数据时优于 ArrayList。

对于快速访问对象的需求，使用 ArrayList 实现执行效率上会比较好。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高。

不同的结构对应于不同的算法，有的考虑节省占用空间，有的考虑提高运行效率，对于程序员而言，它们就像是“熊掌”和“鱼肉”，不可兼得。高运行速度往往是以牺牲空间为代价的，而节省占用空间往往是以牺牲运行速度为代价的。

Set

不包含重复元素的集合，并且最多只允许包含一个 null 元素，模拟数学上的 “集合”,未引入新的方法,与List的区别是，List元素有位置概念，Set集合只有元。

Set 是Collection接口的子接口,它主要有两个常用的实现类：HashSet 类和 TreeSet类。

HashSet类

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类。HashSet 是按照 Hash 算法来存储集合中的元素。因此具有很好的存取和查找性能。

HashSet 具有以下特点：

不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也有可能发生变化。
HashSet 不是同步的，如果多个线程同时访问或修改一个 HashSet，则必须通过代码来保证其同步。
集合元素值可以是 null。

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据该 hashCode 值决定该对象在 HashSet 中的存储位置。如果有两个元素通过 equals() 方法比较返回的结果为 true，但它们的 hashCode 不相等，HashSet 将会把它们存储在不同的位置，依然可以添加成功。也就是说，两个对象的 hashCode 值相等且通过 equals() 方法比较返回结果为 true，则 HashSet 集合认为两个元素相等。

下面的代码演示了创建两种不同形式的 HashSet 对象。

HashSet hs = new HashSet();    // 调用无参的构造函数创建HashSet对象
HashSet<String> hss = new HashSet<String>();    // 创建泛型的 HashSet 集合对象

例子1、编写一个 Java 程序，使用 HashSet 创建一个 Set 集合，并向该集合中1添加 4 套教程。具体实现代码如下：

public static void main(String[] args) {
    HashSet<String> courseSet = new HashSet<String>(); // 创建一个空的 Set 集合
    String course1 = new String("Java入门教程");
    String course2 = new String("Python基础教程");
    String course3 = new String("C语言学习教程");
    String course4 = new String("Golang入门教程");
    courseSet.add(course1); // 将 course1 存储到 Set 集合中
    courseSet.add(course2); // 将 course2 存储到 Set 集合中
    courseSet.add(course3); // 将 course3 存储到 Set 集合中
    courseSet.add(course4); // 将 course4 存储到 Set 集合中
    System.out.println("C语言中文网教程有：");
    
    Iterator<String> it = courseSet.iterator();
    
    while (it.hasNext()) {
        System.out.println("《" + (String) it.next() + "》"); // 输出 Set 集合中的元素
    }
    System.out.println("有" + courseSet.size() + "套精彩教程！");
}
/*
C语言中文网教程有：
《Java入门教程》
《C语言学习教程》
《Python基础教程》
《Golang入门教程》
有4套精彩教程！
*/

TreeSet类

TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口，可以实现对集合进行自然排序，因此使用 TreeSet 类实现的 Set 接口默认情况下是自然排序的，这里的自然排序指的是升序排序。

注意：在使用自然排序时只能向 TreeSet 集合中添加相同数据类型的对象，否则会抛出 ClassCastException 异常。

TreeSet 只能对实现了 Comparable 接口的类对象进行排序，因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小。例如 a.compareTo(b)，如果 a 和 b 相等，则该方法返回 0；如果 a 大于 b，则该方法返回大于 0 的值；如果 a 小于 b，则该方法返回小于 0 的值。

实现Comparable接口类对象的比较方法：

类	比较方式
包装类（BigDecimal、Biglnteger、 Byte、Double、 Float、Integer、Long 及 Short)	按数字大小比较
Character	按字符的 Unicode 值的数字大小比较
String	按字符串中字符的 Unicode 值的数字大小比较

TreeSet类的常用方法

方法名称	说明
E first()	返回此集合中的第一个元素。其中，E 表示集合中元素的数据类型
E last()	返回此集合中的最后一个元素
E poolFirst()	获取并移除此集合中的第一个元素
E poolLast()	获取并移除此集合中的最后一个元素
SortedSet subSet(E fromElement,E toElement)	返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement 对象之间的所有对象。包含 fromElement 对象，不包含 toElement 对象
SortedSet headSet<E toElement〉	返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。不包含 toElement 对象
SortedSet tailSet(E fromElement)	返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对象。包含 fromElement 对象

public class Test08{
    public static void main(String[] args){
        TreeSet<Double> scores = new TreeSet<Double>();//创建 TreeSet集合
        Scanner input = new Scanner(System.in);
        System.out.println("------------学生成绩管理系统-------------");
        for(int i = 0; i < 5; i++){
             System.out.println("第" + (i + 1) + "个学生成绩：");
            double score = input.nextDouble();
             // 将学生成绩转换为Double类型，添加到TreeSet集合中	
            scores.add(Double.valueOf(score));
        }
        Iterator<Double> it = scores.iterator();//创建Iterator对象
         System.out.println("学生成绩从低到高的排序为：");
        while(it.hasNext()){
            System.out.print(it.next() + '\t');
        }
         System.out.println("\n请输入要查询的成绩：");
        double searchScore = input.nextDouble();
        if(scores.contains(searchScore)){//contains()函数是Set类中的
              System.out.println("成绩为： " + 	searchScore + " 的学生存在！");
        } else {
            System.out.println("成绩为： " + searchScore + " 的学生不存在！");
        }
         // 查询不及格的学生成绩
        SortedSet<Double> score1 = scores.headSet(60.0);
        for(int i = 0; i < score1.toArray().length; i++){//toArray()将集合 转换成字符串数组。
           System.out.print(score1.toArray()[i] + "\t"); 
        }
        // 查询90分以上的学生成绩
        SortedSet<Double> score2 = scores.tailSet(90.0);
        System.out.println("\n90 分以上的成绩有：");
        for (int i = 0; i < score2.toArray().length; i++) {
            System.out.print(score2.toArray()[i] + "\t");
        }
    }
}

Map

是一组成对的<键-值>对象，Map 集合中的每一个元素都包含一个键（key）对象和一个值（value）对象。用于保存具有映射关系的数据。

Map 的 key 不允许重复，value 可以重复，即同一个 Map 对象的任何两个 key 通过 equals 方法比较总是返回 false。

包含HashMap、TreeMap、LinkedHashMap、Hashtable……

注意：TreeMap 类的使用方法与 HashMap 类相同，唯一不同的是 TreeMap 类可以对键对象进行排序

方法名称	说明
void clear()	删除该 Map 对象中的所有 key-value 对。
boolean containsKey(Object key)	查询 Map 中是否包含指定的 key，如果包含则返回 true。
boolean containsValue(Object value)	查询 Map 中是否包含一个或多个 value，如果包含则返回 true。
V get(Object key)	返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型
V put(K key, V value)	向 Map 集合中添加键-值对，如果当前 Map 中已有一个与该 key 相等的 key-value 对，则新的 key-value 对会覆盖原来的 key-value 对。
void putAll(Map m)	将指定 Map 中的 key-value 对复制到本 Map 中。
V remove(Object key)	从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如果该 key 不存在，则返回 null
boolean remove(Object key, Object value)	这是 Java 8 新增的方法，删除指定 key、value 所对应的 key-value 对。如果从该 Map 中成功地删除该 key-value 对，该方法返回 true，否则返回 false。
Set entrySet()	返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据类型为 Map.Entry
Set keySet()	返回 Map 集合中所有键对象的 Set 集合
boolean isEmpty()	查询该 Map 是否为空（即不包含任何 key-value 对），如果为空则返回 true。
int size()	返回该 Map 里 key-value 对的个数
Collection values()	返回该 Map 里所有 value 组成的 Collection

 public static void main(String[] args) {
        HashMap users = new HashMap();
        users.put("11", "张浩太"); // 将学生信息键值对存储到Map中
        users.put("22", "刘思诚");
        users.put("33", "王强文");
        users.put("44", "李国量");
        users.put("55", "王路路");
        System.out.println("******** 学生列表 ********");
        Iterator it = users.keySet().iterator();//将users 里的key值提取出来存入 it中
        while (it.hasNext()) {
            // 遍历 Map
            Object key = it.next();
            Object val = users.get(key);
            System.out.println("学号：" + key + "，姓名:" + val);
        }
        Scanner input = new Scanner(System.in);
        System.out.println("请输入要删除的学号：");
        int num = input.nextInt();
        if (users.containsKey(String.valueOf(num))) { // 判断是否包含指定键
            users.remove(String.valueOf(num)); // 如果包含就删除
        } else {
            System.out.println("该学生不存在！");
        }
        System.out.println("******** 学生列表 ********");
        it = users.keySet().iterator();
        while (it.hasNext()) {
            Object key = it.next();
            Object val = users.get(key);
            System.out.println("学号：" + key + "，姓名：" + val);
        }
    }

1.在 for 循环中使用 entries 实现 Map 的遍历（最常见和最常用的）。

public static void main(String[] args) {
	Map<String,String> map = new HashMap<String,String>();
    map.put("Java入门教程", "http://c.biancheng.net/java/");
    map.put("C语言入门教程", "http://c.biancheng.net/c/");
    for(Map.Entry<String,String> entry : map.entrySet()){
        String mapKey = entry.getKey();
        String mapValue = entry.getValue();
        System.out.println(mapKey +":" + mapValue);
    }
    
}

2.使用 for-each 循环遍历 key 或者 values，一般适用于只需要 Map 中的 key 或者 value 时使用。性能上比 entrySet 较好。

Map<String,String> map = new HashMap<String,String>();
map.put("Java入门教程", "http://c.biancheng.net/java/");
map.put("C语言入门教程", "http://c.biancheng.net/c/");
//打印键集合
for(String key:map.keySet()){
    System.out.println(key);
}
//打印值集合
for(String value:map.values()){
    System.out.println(val);
}

3.使用迭代器（Iterator）遍历

Map<String,String>map = new HashMap<String,String>();
map.put("Java入门教程", "http://c.biancheng.net/java/");
map.put("C语言入门教程", "http://c.biancheng.net/c/");
Iterator<Entry<String,String>> entries = map.entrySet().iterator();//将键值对 转化为Iterator
while(entires.hasNext()){
    Entry<String,String> entry = entries.next();
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + ":" + value);
}

4.通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作。

for(String key : map.ketSet()){
    String value = map.get(key);
    System.out.println(key + ":" + value);
}

主要的方法有：

V put(K key, V value);存

V get(Object key);取（以key 取值value)）

Lterator接口

迭代器：Iterator 主要用于迭代访问（即遍历) collection 中的元素

列：List<Integer> list = new ArrayList<Integer>();

Iterator<Integer> it = list.iterator();

在Map中使用

Map<String,String> map = new HashMap<String,String>();

 Iterator<String> it =keys.iterator();

Vector类

:变长的对象数组

public class Vector<E>extends AbstractList<E>implements [List]<E>

可以根据下标来引用元素，可以追加对象元素数量，可以修改、删除其中的对象。

Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

创建Vector：不必须指明序列中元素的类型，可在使用时确定。——Vector myVector = new Vector(100,50);//自动增加量

注：使用Vector时一定要先创建后使用，否则会出现堆栈溢出或使用null指针等异常——Vdctor a; ——a.add("abc");

addElement(Object obj):将新元素添加在向量序列的尾部

insertElement(Object obj,int index):将新元素插入在序列的指定位置处

修改与删除

void setElementAt(Object obj,int dex):将index位置处的对象设置成obj

Boolean removeElement(Object obj):删除向量中第一个与指定的obj对象相同的元素，同时将后面元素前补上空位

void removeElementAt(int index):删除index指定位置处的元素，同时将后面的元素向前提

void removeAllElements():清除向量中的所有元素

查找

Object elementAt(int index):返回指定位置index处的元素：
需要强制类型转换：
D200_Card myCar = (D200_Card) myVector.elementAt(0);

boolean contains(Object obj) : 检查向量中是否包含对象元素obj

int indexOf(Object obj,int start_index):从start_index位置开始向后搜索，返回第一个与对象obj相同的元素的位置。若不存在，则返回-1

int lastIndexOf(Object obj,int start_index)：从start_index位置开始向前搜索，返回第一个与对象obj相同的元素的位置。若不存在，则返回-1。

Collections类

Collections 类是 Java 提供的一个操作 Set、List 和 Map 等集合的工具类。Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、查找替换和复制等操作。

Collections 提供了如下方法用于对 List 集合元素进行排序。

void reverse(List list)：对指定 List 集合元素进行逆向排序。
void shuffle(List list)：对 List 集合元素进行随机排序（shuffle 方法模拟了“洗牌”动作）。
void sort(List list)：根据元素的自然顺序对指定 List 集合的元素按升序进行排序。
void sort(List list, Comparator c)：根据指定 Comparator 产生的顺序对 List 集合元素进行排序。
void swap(List list, int i, int j)：将指定 List 集合中的 i 处元素和 j 处元素进行交换。Collections.swap(vector, 0, 4);
void rotate(List list, int distance)：当 distance 为正数时，将 list 集合的后 distance 个元素“整体”移到前面；当 distance 为负数时，将 list 集合的前 distance 个元素“整体”移到后面。该方法不会改变集合的长度。

 ArrayList<Student> list02 = new ArrayList<>();
       list02.add(new Student("a迪丽热巴",19));
       list02.add(new Student("古力娜扎",20));
       list02.add(new Student("杨幂",18));
       list02.add(new Student("b杨幂",19));
        System.out.println(list02);

      /*此方法简便！！！ 
      Collections.sort(list02, new Comparator<Student>() {
           @Override
           public int compare(Student o1, Student o2) {
               return o1.getAge()-o2.getAge();
           }
       });*/

        //扩展：了解
        Collections.sort(list02, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照年龄排序
                int result = o1.getAge()-o2.getAge();
                //如果两个人年龄相同，使用姓名的第一个字母比较

                if (result==0){
                  result =  o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list02);
/********************************/
//创建的Student类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

查找、替换操作

Collections 还提供了如下常用的用于查找、替换集合元素的方法。

int binarySearch(List list, Object key)：使用二分搜索法搜索指定的 List 集合，以获得指定对象在 List 集合中的索引。如果要使该方法可以正常工作，则必须保证 List 中的元素已经处于有序状态。
Object max(Collection coll)：根据元素的自然顺序，返回给定集合中的最大元素。
Object max(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最大元素。
Object min(Collection coll)：根据元素的自然顺序，返回给定集合中的最小元素。
Object min(Collection coll, Comparator comp)：根据 Comparator 指定的顺序，返回给定集合中的最小元素。
void fill(List list, Object obj)：使用指定元素 obj 替换指定 List 集合中的所有元素。
int frequency(Collection c, Object o)：返回指定集合中指定元素的出现次数。
int indexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中第一次出现的位置索引；如果父 List 中没有出现这样的子 List，则返回 -1。
int lastIndexOfSubList(List source, List target)：返回子 List 对象在父 List 对象中最后一次出现的位置索引；如果父 List 中没有岀现这样的子 List，则返回 -1。
boolean replaceAll(List list, Object oldVal, Object newVal)：使用一个新值 newVal 替换 List 对象的所有旧值 oldVal。

复制

Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中。执行 copy() 方法后，目标集合中每个已复制元素的索引将等同于源集合中该元素的索引。

copy() 方法的语法格式如下：

void copy(List <? super T> dest,List<? extends T> src)

其中，dest 表示目标集合对象，src 表示源集合对象。

Collections.copy(destList, srcList);

String

toString()

Java里面所有的类都有一个共同的父类Object，不管你愿不愿意都得继承他（默认继承，不用加extends）,当重写这个toString类后需要把该类转换成String类型的时候就会调用这个方法。用例toString

String的常用方法（11）

计算字符串长度： int len = String.length();

判断字符串文本是否相等，a.equals(b);->true相等 false不等

public boolean startsWith(String s)

public boolean endsWith(String s)

public boolean regionMatches(int firstStart,String other,int otherStart,int length)比较两个字符串子串是否相同

//例子: 判断一个字符串中共出现几个en
{   public static void main(String args[])
    {  int number=0; 
       String s="student;entropy;engage,english,client";
       for(int k=0;k<s.length();k++)
        {  
           if(s.regionMatches(k,"en",0, 2))
             { System.out.printf("k=%d\n",k);
               number++;
             }
         } //从k的位置开始取长度为2的字串，从“en”的0开始取长度为2的字串
       System.out.println("number="+number);
    }
}
/*输出：
    k=4
	k=8
	k=16
	k=23
	k=34
	number=5
*/

public int compareTo(String s)

字符串对象可以使用String类中的compareTo（String s）方法，按字典序与参数s指定的字符串比较大小。

如果当前字符串与s相同，该方法返回值0；如果当前字符串对象大于s，该方法返回正值；如果小于s，该方法返回负值。

public int indexOf(String s)

字符串调用方法indexOf (String s)从当前字符串的头开始检索字符串s，并返回首次出现s的位置。如果没有检索到字符串s，该方法返回的值是-1。

字符串调用indexOf(String s ,int startpoint)方法从当前字符串的startpoint位置处开始检索字符串s，并返回首次出现s的位置。如果没有检索到字符串s，该方法返回的值是-1。

字符串调用lastIndexOf (String s)方法从当前字符串的头开始检索字符串s，并返回最后出现s的位置。如果没有检索到字符串s，该方法返回的值是-1。

 String tom="I am a good cat";
 System.out.println(tom.indexOf("I"));
 System.out.println(tom.indexOf("a"));
 System.out.println(tom.indexOf("a",7));
 System.out.println(tom.indexOf("good"));
 System.out.println(tom.indexOf("w",2));

public String substring()

字符串对象调用substring(int startpoint) 方法获得一个当前字符串的子串，该子串是从当前字符串的startpoint处截取到字符串的末尾所得到的字符串。

字符串对象调用substring(int start ,int end)方法获得一个当前字符串的子串，该子串是从当前字符串的start处截取到end处所得到的字符串，但不包括end处所对应的字符。

String tom="I love them";
String s1=tom.substring(2);
String s2=tom.substring(2,5);
System.out.println(s1);
System.out.println(s2);

public String replaceAll(String oldString,String newString)

字符串对象s调用该方法，可以通过用参数newString指定的字符串替换s中由oldString指定的所有字符串而得到的字符串；

public String replaceFirst(String oldString,String newString)

换第一个oldString

public String trim()

一个字符串s通过调用方法trim()得到一个字符串对象，该字符串对象是s去掉前后空格后的字符串

数字转换为字符串

String str=String.valueOf(123.56)

int a = int.parseInt(String a)

对象的字符串表示：

Object类有一个public 方法toString()，一个对象通过调用该方法可以获得该对象的字符串表示
Object类的toString的实现为默认对象的地址值
重写toString方法可以定制化对象字符串表示

import java.util.Date;
import java.awt.*;
public class Test6
{  public static void main(String args[])
   {  Date date=new Date();
      Button button=new Button("确定");
      System.out.println(date.toString());
      System.out.println(button.toString());  
   }
}

读取文件：

public class Demo4 {
	public static void main(String[] args) {
		String fileone = "C:\\Users\\刘\\Desktop\\实验七 数据\\top10input.txt";
		File file = new File(fileone);
		ArrayList<Student> student = new ArrayList<>();//创建一个Student的集合
		try {
			Scanner scanner = new Scanner(file);//读取文件
			scanner.nextLine();//将文件首行“学号	     语文	数学 英语”除去
			while(scanner.hasNext()) {
				ArrayList<String> list = new ArrayList<>();//用于存储读取的每一行，每次读取都是新建（比较特殊，while每次都是新的一行）
				for(String x : scanner.nextLine().split("\\s+")) {
					list.add(x);//list 中存储一行的信息,例如“23470253144,68,79,60”
					String[] strings = new String[list.size() - 1];
					strings = list.get(0).split(",");
					Student a1 = new Student(strings[0],strings[1],strings[2],strings[3]);
					a1.sum();
					student.add(a1);
//					System.out.println(a1.number+" "+a1.a1+" "+a1.a2+" "+a1.a3+" "+a1.sum);
				}//接下来的操作便是 提取他们将其存入student 集合中！！！
//				System.out.println(list.size());
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		//开始依据sum排序，并输出前10位。
		
	}

}

ArrayList自定义排序

class Student implements Comparable{
	public String number,a1,a2,a3;
	public int sum;
	int math ;
	Student(String number,String a1,String a2,String a3){
		this.number = number;
		this.a1 = a1;
		this.a2 = a2;
		this.a3 = a3;
	}

	void sum() {
		sum = Integer.parseInt(a1) + Integer.parseInt(a2) + Integer.parseInt(a3);
	}
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		Student s = (Student) o;
		this.math = Integer.parseInt(a2);//将其转为数字型
		s.math = Integer.parseInt(a2);//将其转为数字型
		if(this.sum > s.sum) {
			return -1;
		} 
		else if(this.sum < s.sum) {
			return 1;
		} 
		else {
			
			if(this.math > s.math) {
				return -1;
			} 
			else {
				return 1;
			}
		}
	}
}

StringTokenizer类

将字符串分解成可被独立使用的单词时，可以使用java.util包中的StringTokenizer类，该类有两个常用的构造方法：

StringTokenizer（String s）为字符串s构造一个分析器。使用默认的分隔符集合，即空格符（若干个空格被看做一个空格）、换行符、回车符、Tab符、进纸符。

StringTokenizer(String s, String delim) 为字符串s构造一个分析器。参数delim中的字符被作为分隔符。

主要方法：

当调用nextToken()时，都将在字符串中获得下一个语言符号，同时，字符串分析器中的负责计数的变量的值就自动减一；

hasMoreTokens()，只要字符串中还有语言符号，返回true，否则为false；

countTokens()，得到分析器中计数变量的值

{  public static void main(String args[])
   {  String s="I am James,she is my girlfriend";
      StringTokenizer fenxi=new StringTokenizer(s,“ ,”);   //空格和逗号分隔
      int number=fenxi.countTokens();
      while(fenxi.hasMoreTokens()) 
       {  String str=fenxi.nextToken();
          System.out.println(str);
          System.out.println("还剩"+fenxi.countTokens()+"个单词");
       }
     System.out.println("s共有单词："+number+"个");
   }

字符串与字符、字节数组

public void getChars(int start,int end,char c[],int offset ) ：字符串调用getChars方法将当前字符串中的一部分字符拷贝到参数c指定的数组中。将字符串中从位置start到end-1位置上的字符拷贝的数组c中，并从数组c的offset处开始存放这些字符。需要注意的是，必须保证数组c能容纳下要被拷贝的字符。

public char[] toCharArray() ：字符串对象调用该方法可以初始化一个字符数组，该数组的长度与字符串的长度相等，并将字符串对象的全部字符拷贝到该数组中。

String s;
String[] c = new String[2];
s.getChar(0,2,c,0);

StringBuffer类

String类创建的字符串对象是不可修改的，也就是说，String字符串不能修改、删除或替换字符串中的某个字符，即String对象一旦创建，那么实体是不可以再发生变化的.

StringBuffer类能创建可修改的字符串序列，也就是说，该类的对象的实体的内存空间可以自动的改变大小，便于存放一个可变的字符序列。

StringBuffer() 无参数创建StringBuffer对象，初始容量为16个;

StringBuffer(int size) 初始容量为size个字符；

StringBuffer(String s) 初始容量为字符串s的长度额外再加16字符。

常用方法：

Append() 可将其他Java类型数据转化为字符串后再追加到StringBuffer对象中；

char charAt (int n) 得到第n个位置上的字符；

void setCharAt (int n, char ch) 将第n个位置上的字符用ch指定的字符替换；

StringBuffer insert (int index, String str)将一个字符串str插入到第index位置上，并返回当前对象的引用；

public StringBuffer reverse() 将字符序列翻转；

StringBuffer delete (int startIndex, int endIndex) 删除从startIndex开始到endIndex-1的子串；

StringBuffer replace( int startIndex, int endIndex, String str) 将从startIndex开始到endIndex-1的子串用字符串str替换。

public static void main(String args[]) {
		StringBuffer str = new StringBuffer("62791720");
		str.insert(0, "010-");
		System.out.println(str);
		str.setCharAt(7, '8');
		System.out.println(str);
		str.setCharAt(str.length() - 1, '7');
		System.out.println(str);
		str.append("-446");
		System.out.println(str);
		str.reverse();
		System.out.println(str);
	}
//输出：
/*010-62791720
  010-62781720
  010-62781727
  010-62781727-446
  644-72718726-010*/

StringBuilder类

异常

介绍

在编写程序时，经常要在可能出现错误的地方加上检测的代码，如进行x/y运算时，要检测分母为0，数据为空，输入的不是数据而是字符等。过多的if-else分支会导致程序的代码加长、臃肿，可读性差。因此采用异常处理机制。

在 Java 中一个异常的产生，主要有如下三种原因：

Java 内部错误发生异常，Java 虚拟机产生的异常。
编写的程序代码中的错误所产生的异常，例如空指针异常、数组越界异常等。
通过 throw 语句手动生成的异常，一般用来告知该方法的调用者一些必要信息。

我们把生成异常对象，并把它提交给运行时系统的过程称为拋出（throw）异常。

Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，使得程序简洁、优雅，并易于维护。

异常的根类是java.lang.Throwable。其下有两个子类： java.lang.Exception与java.lang.Error，平常所说的异常指java.lang.Exception。

运行时异常和非运行时异常也称为 不检查异常和检查异常。

Exception 类用于用户程序可能出现的异常情况，它也是用来创建自定义异常类型类的类。
Error 定义了在通常环境下不希望被程序捕获的异常。一般指的是 JVM 错误，如堆栈溢出。

讨论Exception类型异常：

运行时异常都是 RuntimeException 类及其子类异常，如 NullPointerException、IndexOutOfBoundsException 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般由程序逻辑错误引起，程序应该从逻辑角度尽可能避免这类异常的发生。

非运行时异常是指 RuntimeException 以外的异常，类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如 IOException、ClassNotFoundException 等以及用户自定义的 Exception 异常（一般情况下不自定义检查异常）。

Java中常见运行时异常RunTimeException

异常类型	说明
ArithmeticException	算术错误异常，如以零做除数
ArraylndexOutOfBoundException	数组索引越界
ArrayStoreException	向类型不兼容的数组元素赋值
ClassCastException	类型转换异常
IllegalArgumentException	使用非法实参调用方法
lIIegalStateException	环境或应用程序处于不正确的状态
lIIegalThreadStateException	被请求的操作与当前线程状态不兼容
IndexOutOfBoundsException	某种类型的索引越界
NullPointerException	尝试访问 null 对象成员，空指针异常
NegativeArraySizeException	再负数范围内创建的数组
NumberFormatException	数字转化格式异常，比如字符串到 float 型数字的转换无效
TypeNotPresentException	类型未找到

Java常见非运行时异常

异常类型	说明
ClassNotFoundException	没有找到类
IllegalAccessException	访问类被拒绝
InstantiationException	试图创建抽象类或接口的对象
InterruptedException	线程被另一个线程中断
NoSuchFieldException	请求的域不存在
NoSuchMethodException	请求的方法不存在
ReflectiveOperationException	与反射有关的异常的超类

Java中Error和Exception的异常同

Error（错误）和 Exception（异常）都是 java.lang.Throwable 类的子类，在 Java 代码中只有继承了 Throwable 类的实例才能被 throw 或者 catch。

Exception 是程序正常运行过程中可以预料到的意外情况，并且应该被开发者捕获，进行相应的处理。

Error 是指正常情况下不大可能出现的情况，绝大部分的 Error 都会导致程序处于非正常、不可恢复状态。所以不需要被开发者捕获。Error错误是任何处理技术都无法恢复的情况，肯定会导致程序非正常终止。且属于未检查类型。

Exception又可分为可检查（checked）异常和不检查（unchecked）异常。

可检查异常在源码里必须显示的进行捕获处理，治理是编译期检查的一部分。

不检查异常就是所谓的运行时异常，通常是可以编码避免的逻辑错误，具体根据需要来判断是否需要捕获，并不会在编译器强制要求。

运行时异常（RuntimeException）:
1. NullPropagation:空指针异常：
2. ClassCastException:类型强制转换异常
3. IllegalArgumentException:传递非法参数异常
4. IndexOutOfBoundsException:下标越界异常
5. NumberFormatException:数字格式异常
非运行时异常：
1. ClassNotFoundException:找不到指定class的异常
2. IOException:IO操作异常
错误（Error）:
1. NoClassDefFoundError:找不到class定义异常
2. StackOverflowError:深递归导致栈被耗尽而抛出的异常
3. OutOfMemoryError:内存溢出异常

声明异常——>抛出异常——>捕获异常

异常处理机制:

Java的异常处理通过5个关键字来实现：try、catch、throw和finally。

try catch语句用于捕获并处理异常，finally语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw语句用于抛出异常，throws语句用于声明可能会出现的异常。

异常处理的机制机制如下：

在方法中用try catch 语句捕获并处理异常，catch语句可以有多个，用来匹配多个异常。
对于处理不了的异常或者要转型的异常，在方法的声明处通过throws语句抛出异常，即由上层的调用方法来处理。

try{
    逻辑程序块
} catch(ExceptionTyple1 e){
    处理代码块1
} catch(ExceptionTyple2 e){
    处理代码块2
        throw(e);//再抛出这个“异常”
} finally{
    释放资源代码块
}

在多个 catch 代码块的情况下，当一个 catch 代码块捕获到一个异常时，其它的 catch 代码块就不再进行匹配。

try catch finally执行顺序

仅仅在下面4中情况下不会执行finally语句 :

①.如果在try 或catch语句中执行了System.exit(0)。

②.在执行finally之前jvm崩溃了。

③.try语句中执行死循环。

④.电源断电

①、不管有没有出现异常，finally块中代码都会执行；

  public void demo1(){
        try {

          System.out.println(result);

        } catch (Exception e) {                     
            System.out.println(e.getMessage());
        }
         finally {            
                System.out.println("finally trumps. ");
            }
//输出结果为：
result
finally trumps .

②、当try和catch中有return时，finally仍然会执行；

public static int demo2() {
        try {
            return 0;
        }
        finally {
            System.out.println("finally trumps return.");
        }
    }
//输出结果

finally trumps return.
0   
    //当finally里面没有return语句是，执行try 和finally语句之后最后再执行return。

③、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；

public static int demo3()
    {
         int i = 0;
            try {
                i = 2;
                return i;
            } finally {
                i = 12;
                System.out.println("finally trumps return.");
            }       
    }
//输出结果
    finally trumps return.
    2
//执行前的值
此处中finally中对i赋值12但是demo3的返回值仍然是2，也就是在finally中对i赋值并未改变i的返回值

④、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

    public static int demo4() {
        int i = 0;
        try {
            return i;
        } finally {
            i = 12;
            System.out.println("finally trumps return.");
            return i;
        }
    }
    //输出结果
    finally trumps return.
    12  
        上面为什么会返回12呢？因为在程序还未执行try中的return语句时就先执行了finally里面的return语句所以返回结果为12。

可以有多个catch块，并且try块后面，只能有1个或1个finally块。
try块后面，如果没有catch块，则后面必须有一个finally

public static void main(String[] args) {
    try {
        System.out.println("try...");
    }
    finally {
        System.out.println("finally...");
    }
}

//输出结果：
//try...
//finally...

执行代码捕获异常后，进入catch块，try中出现异常代码后面的代码不会在继续执行
当try块中或者catch块中遇到return语句时，先执行完finally里面的代码后，再执行return返回语句

public static void main(String[] args) {
    try {
        System.out.println("try...");
        return;
    } catch (ArithmeticException e) {
        System.out.println("ArithmeticException...");
    } catch (NullPointerException e) {
        System.out.println("NullPointerException...");
    } finally {
        System.out.println("finally...");
    }
}

//输出结果：
//try...
//finally...

throws 和 throw:声明和抛出异常

Java 中的异常处理除了捕获异常和处理异常之外，还包括声明异常和拋出异常。实现声明和抛出异常的关键字非常相似，它们是 throws 和 throw。可以通过 throws 关键字在方法上声明该方法要拋出的异常，然后在方法内部通过 throw 拋出异常对象。

throws声明异常

当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，以便将该异常传递到方法的外部进行处理。使用 throws 声明的方法表示此方法不处理异常。throws 具体格式如下：

returnType method_name(paramList) throws Exception 1,Exception2,…{…}

如果有多个异常类，它们之间用逗号分隔。这些异常类可以是方法中调用了可能拋出异常的方法而产生的异常，也可以是方法体中生成并拋出的异常。

使用 throws 声明抛出异常的思路是，当前方法不知道如何处理这种类型的异常，该异常应该由向上一级的调用者处理；如果 main 方法也不知道如何处理这种类型的异常，也可以使用 throws 声明抛出异常，该异常将交给 JVM 处理。JVM 对异常的处理方法是，打印异常的跟踪栈信息，并中止程序运行，这就是前面程序在遇到异常后自动结束的原因。

import java.io.FileInputStream;
import java.io.IOException;
public class Test04 {
    public void readFile() throws IOException {
        // 定义方法时声明异常
        FileInputStream file = new FileInputStream("read.txt"); // 创建 FileInputStream 实例对象
        int f;
        while ((f = file.read()) != -1) {
            System.out.println((char) f);
            f = file.read();
        }
        file.close();
    }
    public static void main(String[] args) {
        Throws t = new Test04();
        try {
            t.readFile(); // 调用 readFHe()方法
        } catch (IOException e) {
            // 捕获异常
            System.out.println(e);
        }
    }
}以上代码，首先在定义 readFile() 方法时用 throws 关键字声明在该方法中可能产生的异常，然后在 main() 方法中调用 readFile() 方法，并使用 catch 语句捕获产生的异常。

方法重写时声明抛出异常的限制

使用 throws 声明抛出异常时有一个限制，是方法重写中的一条规则：子类方法声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相同，子类方法声明抛出的异常不允许比父类方法声明抛出的异常多。看如下程序。

public class OverrideThrows {//父类
    public void test() throws IOException {
        FileInputStream fis = new FileInputStream("a.txt");
    }
}
class Sub extends OverrideThrows {//子类
    
    // 子类方法声明抛出了比父类方法更大的异常
    // 所以下面方法出错
    public void test() throws Exception {
    }Exception比它的父类大
}
错误！！！
    
   
所以在编写类继承代码时要注意，子类在重写父类带 throws 子句的方法时，子类方法声明中的 throws 子句不能出现父类对应方法的 throws 子句中没有的异常类型，因此 throws 子句可以限制子类的行为。也就是说，子类方法拋出的异常不能超过父类定义的范围。

对于自定义类throws的使用，在main中的使用方法

 public static void main(String[] args) {
        // TODO Auto-generated method stub
       int result = divide(4,2);
       System.out.println(result);
    }
    public static int divide(int x,int y) throws Exception
    {
        int result = x/y;
        return result;
    }
这样是错误的，需要在main中使用throws 或者try catch语句
    public static void main(String[] args) {
        
      try {
         int    result = divide(4,2);
          System.out.println(result);
       } catch (Exception e) {
        
          e.printStackTrace();
       }
      
    }
=======或者
    public static void main(String[] args) throws Exception {
          int    result = divide(4,0);
          System.out.println(result);
    }

throw抛出异常

与 throws 不同的是，throw 语句用来直接拋出一个异常，后接一个可拋出的异常类对象，其语法格式如下：

throw ExceptionObject;

其中，ExceptionObject 必须是 Throwable 类或其子类的对象。如果是自定义异常类，也必须是 Throwable 的直接或间接子类。例如，以下语句在编译时将会产生语法错误：

throw new String("拋出异常");    // String类不是Throwable类的子类

package Collection排序;

import java.util.Scanner;

public class Test05 {
	public boolean validateUserName(String username){
		boolean con = false;
		if(username.length() > 8) {
			for(int i = 0; i < username.length(); i++) {
				char ch = username.charAt(i);
				if( ch >= '0' && ch <= '9' || ch >= 'a' && ch <='z' || ch > 'A' && ch <= 'Z') {
					con = true;
				} else {
					con = false;
					throw new IllegalArgumentException("用户长度必须由字母和数字组成!");
				}
			}
			
		}else {
			throw new IllegalArgumentException("用户长度必须大于8位");
		}
		return con;
	}
	public static void main(String[] args){
		Test05 te = new Test05();
		Scanner input = new Scanner(System.in);
		System.out.println("请输入用户名：");
		String username = input.next();
		try {
			boolean con = te.validateUserName(username);
			if(con) {
				System.out.println("用户输入正确");
			}
		} catch(IllegalArgumentException e){
			System.out.println(e);
		}
	}
}

!!throw单独存在，下面不要定义语句，因为执行不到

public class Test05 {
	public static void func() {
		try {
			throw new Exception();
		} catch (Exception e) {
			System.out.println("B");
		}
	}

	public static void main(String[] args) {
		try {
			func();
		} catch (Exception e) {
			System.out.println("C");
		}
		System.out.println("D");
	}
}
输出：
    B
    D

throw new 语句的执行顺序

package Collection排序;

import java.util.Scanner;

public class Test05 {
	static void methodA() {
		try {
			System.out.println("进入方法A");
			throw new RuntimeException("制造异常");
            //先执行finall语句，在执行 throw的语句
		} finally {
			System.out.println("用A方法的finally");
		}
	}

	static void methodB() {
		try 
		{
		System.out.println(
		"进入方法B");
		return;
		} finally 
		{
		System.out.println(
		"调用B方法的finally");
		}
		}

	public static void main(String[] args) {
		try {
			methodA();
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
		methodB();
	}

}

子类继承父类异常

子类的抛出范围不能大于父类，但若父类异常是IOException，子类是RunTimeException，这种情况是可以的。

输入输出流

Java中所有数据都是使用流读写的。流是以组有序的数据序列，将数据从一个地方带到另一个地方。根据数据流向的不同，可以分为输入（input）流和输出（output）流两种。

输入就是将数据从各种输入设备（包括文件、键盘等）中读取到内存中，输出则正好相反，是将数据写入到各种输出设备（比如文件、显示器、磁盘等）。例如键盘就是一个标准的输入设备，而显示器就是一个标准的输出设备，但是文件既可以作为输入设备，又可以作为输出设备。

数据流是 Java 进行 I/O 操作的对象，它按照不同的标准可以分为不同的类别。

按照流的方向主要分为输入流和输出流两大类。
数据流按照数据单位的不同分为字节流和字符流。
按照功能可以划分为节点流和处理流。

数据流的处理只能按照数据序列的顺序来进行，即前一个数据处理完之后才能处理后一个数据。数据流以输入流的形式被程序获取，再以输出流的形式将数据输出到其它设备。

输入流

Java 流相关的类都封装在 java.io 包中，而且每个数据流都是一个对象。所有输入流类都是 InputStream 抽象类（字节输入流）和 Reader 抽象类（字符输入流）的子类。其中 InputStream 类是字节输入流的抽象类，是所有字节输入流的父类，其层次结构如图 3 所示。

InputStream类的层次结构图

InputStream 类中所有方法遇到错误时都会引发 IOException 异常

名称	作用
int read()	从输入流读入一个 8 字节的数据，将它转换成一个 0~ 255 的整数，返回一个整数，如果遇到输入流的结尾返回 -1
int read(byte[] b)	从输入流读取若干字节的数据保存到参数 b 指定的字节数组中，返回的字节数表示读取的字节数，如果遇到输入流的结尾返回 -1
int read(byte[] b,int off,int len)	从输入流读取若干字节的数据保存到参数 b 指定的字节数组中，其中 off 是指在数组中开始保存数据位置的起始下标，len 是指读取字节的位数。返回的是实际读取的字节数，如果遇到输入流的结尾则返回 -1
void close()	关闭数据流，当完成对数据流的操作之后需要关闭数据流
int available()	返回可以从数据源读取的数据流的位数。
skip(long n)	从输入流跳过参数 n 指定的字节数目
boolean markSupported()	判断输入流是否可以重复读取，如果可以就返回 true
void mark(int readLimit)	如果输入流可以被重复读取，从流的当前位置开始设置标记，readLimit 指定可以设置标记的字节数
void reset()	使输入流重新定位到刚才被标记的位置，这样可以重新读取标记过的数据

输出流

在 Java 中所有输出流类都是 OutputStream 抽象类（字节输出流）和 Writer 抽象类（字符输出流）的子类。其中 OutputStream 类是字节输出流的抽象类，是所有字节输出流的父类，其层次结构如图 4 所示。

OutputStream类的层次结构图

OutputStream 类是所有字节输出流的超类，用于以二进制的形式将数据写入目标设备，该类是抽象类，不能被实例化。OutputStream 类提供了一系列跟数据输出有关的方法，如下所示。

名称	作用
int write(b)	将指定字节的数据写入到输出流
int write (byte[] b)	将指定字节数组的内容写入输出流
int write (byte[] b,int off,int len)	将指定字节数组从 off 位置开始的 len 字节的内容写入输出流
close()	关闭数据流，当完成对数据流的操作之后需要关闭数据流
flush()	刷新输出流，强行将缓冲区的内容写入输出流

查看系统默认编码

public class Test05 {
	public static void main(String[] args) {
		System.out.println(System.getProperty("file.encoding"));
	}
}

进程Java File类（文件操作类）详解 (biancheng.net)

标签：Java,String,int,System,笔记,语法,println,集合,out
From： https://www.cnblogs.com/Hygge1024/p/18059977

Java基础 语法笔记