11111

 每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false” ,如果只需比较内容是否相同，应使用 ”equals()” 方法

一旦一个字符串在内存中创建，则这个字符串将不可改变。如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder

1. 处理运行时异常时采用逻辑合理规避同时辅助try-catch处理

2. 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常

3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常

4. 尽量去处理异常，切记只是简单的调用printStackTrace（）去打印输出

5. 具体如何处理异常，要根据不同的业务需求和异常类型去决定

6. 尽量添加finally语句块去释放占用的资源
   

try catch finally语句先catch然后再finally 最后返回main方法中的调用者

集合的作用

public List<Cause> causetoselect;

public CausetoSelect1() {

this.causetoselect=new ArrayList<Cause>();

}

public void add() {

Cause ca1 = new Cause("0","中学");

causetoselect.add(ca1);

Cause ca2 = new Cause("1","大学");

causetoselect.add(ca2);

}

public void test() {

for (Cause ca:causetoselect) {

System.out.println(ca.id+":"+ca.name);

}

}

泛型的概念

泛型的作用

没设置泛型对象都是以Object类型保存，使用时需要转换类型

设置了泛型，就是以设置的类型保存，使用时直接使用

删除对象：

public void remove() {

System.out.println("删除成员");

Cause ca1 = (Cause)causetolist.get(0);

causetolist.remove(ca1);//方法重载，分别是成员或者索引

};

public void remove1() {

System.out.println("删除2");

causetolist.remove(0);

}

public void remove2() {

System.out.println("删除3");

Cause[] ca1= {(Cause)causetolist.get(0),(Cause)causetolist.get(1)};

causetolist.removeAll(Arrays.asList(ca1));

}

列表set修改内容：

public void modify() {

causetolist.set(0,new Cause("0","大学英语"));

};

循环数据：

public void test() {

int list = causetolist.size();

System.out.println("for循环：");

for(int i=0;i<list;i++) {

Cause temp = (Cause)causetolist.get(i);

System.out.println(temp.id+":"+temp.name);

};

};

public void test1() {

Iterator it = causetolist.iterator();//获取迭代器来来循环迭代列表

System.out.println("迭代器循环");

while(it.hasNext()) {      //判断是否有值

Cause temp = (Cause)it.next();

System.out.println(temp.id+":"+temp.name);

};

};

public void test2() {

System.out.println("for-each循环：");

for(Object obj :causetolist) {

Cause temp = (Cause) obj;

System.out.println(temp.id+":"+temp.name);

};

};

package demo;

import java.util.Scanner;

public class Test2 {

String shu[] = { "论语", "三国志", "红楼梦", "十三太保", "西游记", "桃花源记", "桃园结义", "三国演义" }; // 书名数组

public void jie() {

int s = 0; // 初始化主循环条件

while (s == 0) { // 查找方式循环（外循环）

System.out.println("1，按书名查找；2，按书号查找；请输入对应数字");

Scanner in = new Scanner(System.in);

try {

int xuhao = in.nextInt(); // 输入序号

if (xuhao == 1) {

System.out.println("请输入书名");

} // 判断序

else if (xuhao == 2) {

System.out.println("请输入书号");

}

else

System.out.println("指令错误，请重新输入");

while (xuhao == 1) { // 序号1，按书名查找循环（内循环1）

String c = in.next(); // 输入书名

int j = 0; // 定义j，以判断输入的书名是否有与之配对的书，有则加1

for (int i = 0; i < shu.length; i++) { // 书名比较循环，输入的书名与图书馆有的书进行循环比较，书名是否相同

if (c.equals(shu[i])) {

System.out.println("《" + c + "》" + "序号为" + i + ",位于南庭");

j++;

xuhao = 0;

s=0;

break;

}

// 输入书名有对应书籍，j加1，设a为0，以便退出按书名查找循环，s加1，退出查找方式循环，查找完成，break表示退出书名比较循环

if (c.equals("0")) {

j++;

xuhao = 0;

break;

} // 若输入0，则退出书名比较循环，退出按书名查找循环，回到查找方式循环

}

if (j == 0)

System.out.println("该书不存在,请重新输入书名，若输入0，可返回上级");

// j为0，表示输入内容无对应书籍，若无对应，则提示"该书不存在,请重新输入书名，若输入0，可返回上级"，回到按书名查找循环

}

while (xuhao == 2) { // 序号2，按书号查找循环（内循环2）

int c = in.nextInt(); // 输入书号

int j = 0; // 定义j，以判断输入的书号是否有与之配对的书，有则加1

for (int i = 1; i < shu.length + 1; i++) { // 书号比较循环，输入的书号与图书馆有的书进行循环比较，书号是否相同

if (c == i) {

System.out.println("序号为" + i + "的书《" + shu[i - 1] + "》位于南庭");

j++;

xuhao = 0;

s=0;

break;

}

// 输入书号有对应书籍，j加1，设a为0，以便退出按书号查找循环，s加1，退出查找方式循环，查找完成，break表示退出书名比较循环

if (c == 0) {

j++;

xuhao = 0;

break;

} // 若输入0，则退出书名比较循环，退出按书名查找循环，回到查找方式循环

}

if (j == 0)

System.out.println("该书不存在,请重新输入书号，若输入0，可返回上级");

// j为0，表示输入内容无对应书籍，若无对应，则提示"该书不存在,请重新输入书号，若输入0，可返回上级"，回到按书名查找循环

}

} catch (Exception e) {

System.out.println("指令异常，回到主菜单"); // 异常处理

}

}

}

public static void main(String[] args) {

Test2 x = new Test2(); // 创建对象

x.jie(); // 调用jie（）；

}

}

添加addAll的两种方法

CausetoSelect.java:

public void testAdd() {

Cause a1 = new Cause("1","高代");

this.causetolist.add(a1);

Cause temp = (Cause)causetolist.get(0);

System.out.println(temp.id+":"+temp.name);

Cause cause[] = {new Cause("4","概率论"),new Cause("3","数理统计")};

this.causetolist.addAll(Arrays.asList(cause));//将数组实例转换为列表对象

Cause tem1 = (Cause)causetolist.get(1);

System.out.println(tem1.id+":"+tem1.name);

Cause temp2 =(Cause)causetolist.get(2);

System.out.println(temp2.id+":"+temp2.name);

Cause cause1[] = {new Cause("5","时间序列分析"),new Cause("6","抽样技术")};

causetolist.addAll(2, Arrays.asList(cause1));

Cause temp3 = (Cause)causetolist.get(2);

Cause temp4 =(Cause)causetolist.get(3);

System.out.println(temp3.id+":"+temp3.name+","+temp4.id+":"+temp4.name);

};

Cause.java:

package package1;

public class Cause {

 public String name;

 public String id;

 public Cause(String name,String id){

this.id = id;

this.name =name;

 };

}

Student.java:

package package1;

import java.util.HashSet;

import java.util.Set;

public class Student {

public String id;

public String name;

public Set cause;

public Student(String id,String name) {

this.id=id;

this.name=name;

this.cause = new HashSet();

};

}

CausetoSelect.java:

package package1;

import java.util.ArrayList;

import java.util.List;

public class CausetoSelect {

public List causetolist;

public CausetoSelect() {

this.causetolist=new ArrayList();

};

public void testAdd() {

Cause a1 = new Cause("1","高代");

this.causetolist.add(a1);

Cause temp = (Cause)causetolist.get(0);

System.out.println(temp.id+":"+temp.name);

};

public void testAdd1() {

Cause a1 = new Cause("2","数分");

this.causetolist.add(0, a1);;

Cause temp = (Cause)causetolist.get(0);

System.out.println(temp.id+":"+temp.name);

};

public static void main(String[] args) {

// TODO Auto-generated method stub

CausetoSelect test = new CausetoSelect();

test.testAdd();

test.testAdd1();

}

}

Collection接口、子接口以及实现类

Collection接口

是List、Set和Queue接口的父接口

定义了可用操作List、Set和Queue的方法--增删改查

List接口及其实现类--ArrayList

List是元素有序并且可以重复的集合，被称为序列

List可以精确的控制每个元素的插入位置，或删除某个位置元素

ArrayList底层是由数组实现的

Java集合框架体系结构

根接口

1、Collection接口

Collection的子接口

(1)List序列    存储的元素排列有序、可重复、比较常用

实现类

ArrayList   数组序列  

LinkedList  链表

(2)Queue队列  存储的元素排列有序、可重复

实现类

LinkedList实现类   链表

(3)Set集   存储的元素无序、不可重复、比较常用

实现类

HashSet  哈希集

2、Map接口

实现类

HashMap   哈希表  比较常用

在Map类内部会以一个key一个value两个对象为一个映射存储数据，而这样一个映射是Entry类的实例，Entry(键值对)类是Map的内部类，key和value可以为任意类型的对象

集合的作用

异常在实际应用中的经验与总结