异常处理 List集合

    一、异常处理

在Java代码中异常分为两种：1.运行时异常(RuntimeException) 2.非运行时异常
在称呼上运行时异常也被称为(非检查异常)  ；而非运行时异常被称为(检查异常)

 在异常处理中：常用的处理方法：1.避免出错  2.try...catch语句块  3.抛出异常
1、在代码书写过程中 应当尽量避免出错，

 2、也可以利用异常处理的代码来检查 格式：try{可能出现异常的代码}catch(异常的类型的变量){处理方式}

当代码出现异常后，不会往后运行，而是反馈给调用者
如果在出现异常后，及时try..catch抓住后，就不会将异常对象反馈给调用者
在try...catch语句块中，通常喜欢用Exception抓捕未知异常--向上转型
在使用Exception抓捕异常时往往将其写在catch最后一个语句块--抓捕未知异常

既然异常是类，那抛出就应该是对象，那对象有哪些行为呢？
在catch中，可以书写多个catch块，每个catch块的处理方式不同，得到不同的效果

Learn3[] a = new Learn3[10];
try {
String str = null;
//java.lang.NullPointerException--运行时异常
System.out.println(str.length());
a = new Learn3[10];
System.out.println(a[10].toString());
}catch(NullPointerException n) {
System.out.println("我抓到了空指针");
//出现空指针时的解决方案
for (int i = 0; i < a.length; i++) {
a[i] = new Learn3();
}
}catch(ArrayIndexOutOfBoundsException arr) {
System.out.println(a[a.length-1]);
System.out.println("我抓住了下标越界");
}catch(Exception e) {
System.out.println(e.toString());
System.out.println("抓到一个异常");
}

System.out.println(a[9].toString());

什么是集合？--类似于数组又是数据的组合
集合和数组的区别：
数组：长度固定、类型固定、内存连续
集合：长度不固定、类型不固定(泛型之前)

二、List集合

由于集合中并没有指明数据类型，所以所有的元素取出来后都是Object对象
 为了给该集合中的数据的类型进行区分，我们给集合加上一个指定的数据类型--便于使用
 而加上的数据类型称为--泛型--指明集合中的数据类型

ArrayList擅长查询
LinkedList擅长增、删（删除元素会使下标变化）
原因：LinkedList是双向链表连接，元素之间的关系较弱
而ArrayList是按照数组的排列方式，元素之间是连续的

List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
方法一：
for循环遍历
for(String attribute : list) {
  System.out.println(attribute);
}
方法二：
对于ArrayList来说速度比较快, 用for循环, 以size为条件遍历:
for(int i = 0 ; i < list.size() ; i++) {
  system.out.println(list.get(i));
}
方法三：
集合类的通用遍历方式, 用迭代器迭代
Iterator it = list.iterator();
while(it.hasNext()) {
  System.ou.println(it.next);
}

List集合 操作收集

2.list中是否包含某个元素；

方法：.contains（Object o）； 返回true或者false

3.list中根据索引将元素数值改变(替换)；

注意 .set(index, element); 和 .add(index, element); 的不同；

4.list中查看（判断）元素的索引；　　

注意：.indexOf（）； 和  lastIndexOf（）的不同；

5.根据元素索引位置进行的判断;

6.利用list中索引位置重新生成一个新的list（截取集合）；

方法： .subList(fromIndex, toIndex)；　　.size() ； 该方法得到list中的元素数的和

7.对比两个list中的所有元素；

//两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象

8.判断list是否为空；

　　//空则返回true，非空则返回false

 9.返回Iterator集合对象；

1+0.将集合转换为字符串

11.将集合转换为数组；

12.集合类型转换；

List集合操作的一套完整代码

package MyTest01;

  

import java.util.ArrayList;

import java.util.List;

  

public class ListTest01 {

  

   public static void main(String[] args) {

      

       //list中添加，获取，删除元素

       List<String> person= new ArrayList<>();

       person.add( "jackie" );  //索引为0 //.add(e)

       person.add( "peter" );  //索引为1

       person.add( "annie" );  //索引为2

       person.add( "martin" );  //索引为3

       person.add( "marry" );  //索引为4

        

       person.remove( 3 );  //.remove(index)

       person.remove( "marry" );   //.remove(Object o)

        

       String per= "" ;

       per=person.get( 1 );

       System.out.println(per);  .get(index)

        

       for ( int i = 0 ; i < person.size(); i++) {

         System.out.println(person.get(i)); //.get(index)

       }

        

        

      

       //list总是否包含某个元素

       List<String> fruits= new ArrayList<>();

       fruits.add( "苹果" );

       fruits.add( "香蕉" );

       fruits.add( "桃子" );

       //for循环遍历list

       for ( int i = 0 ; i < fruits.size(); i++) {

         System.out.println(fruits.get(i));

       }

       String appleString= "苹果" ;

       //true or false

       System.out.println( "fruits中是否包含苹果：" +fruits.contains(appleString));

        

       if (fruits.contains(appleString)) {

         System.out.println( "我喜欢吃苹果" );

       } else {

         System.out.println( "我不开心" );

       }

        

       //list中根据索引将元素数值改变(替换)

       String a= "白龙马" , b= "沙和尚" , c= "八戒" , d= "唐僧" , e= "悟空" ;

       List<String> people= new ArrayList<>();

       people.add(a);

       people.add(b);

       people.add(c);

       people.set( 0 , d);  //.set(index, element)   //将d唐僧放到list中索引为0的位置，替换a白龙马

       people.add( 1 , e);  //.add(index, element);   //将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位

        

       //增强for循环遍历list

       for (String str:people){

         System.out.println(str);

       }

        

       //list中查看（判断）元素的索引

       List<String> names= new ArrayList<>();

       names.add( "刘备" );  //索引为0

       names.add( "关羽" );  //索引为1

       names.add( "张飞" );  //索引为2

       names.add( "刘备" );  //索引为3

       names.add( "张飞" );  //索引为4

       System.out.println(names.indexOf( "刘备" ));

       System.out.println(names.lastIndexOf( "刘备" ));

       System.out.println(names.indexOf( "张飞" ));

       System.out.println(names.lastIndexOf( "张飞" ));

        

       //根据元素索引位置进行的判断

       if (names.indexOf( "刘备" )== 0 ) {

         System.out.println( "刘备在这里" );

       } else if (names.lastIndexOf( "刘备" )== 3 ) {

         System.out.println( "刘备在那里" );

       } else {

         System.out.println( "刘备到底在哪里？" );

       }

        

       //利用list中索引位置重新生成一个新的list（截取集合）

       List<String> phone= new ArrayList<>();

       phone.add( "三星" );  //索引为0

       phone.add( "苹果" );  //索引为1

       phone.add( "锤子" );  //索引为2

       phone.add( "华为" );  //索引为3

       phone.add( "小米" );  //索引为4

       //原list进行遍历

       for (String pho:phone){

         System.out.println(pho);

       }

       //生成新list

       phone=phone.subList( 1 , 4 ); //.subList(fromIndex, toIndex)   //利用索引1-4的对象重新生成一个list，但是不包含索引为4的元素，4-1=3

       for ( int i = 0 ; i < phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和

         System.out.println( "新的list包含的元素是" +phone.get(i));

       }

        

       //对比两个list中的所有元素

       //两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象

       if (person.equals(fruits)) {

         System.out.println( "两个list中的所有元素相同" );

       } else {

         System.out.println( "两个list中的所有元素不一样" );

       }

        

       if (person.hashCode()==fruits.hashCode()) {

         System.out.println( "我们相同" );

       } else {

         System.out.println( "我们不一样" );

       }

        

        

       //判断list是否为空

       //空则返回true，非空则返回false

       if (person.isEmpty()) {

         System.out.println( "空的" );

       } else {

         System.out.println( "不是空的" );

       }

        

       //返回Iterator集合对象

       System.out.println( "返回Iterator集合对象:" +person.iterator());

        

       //将集合转换为字符串

       String liString= "" ;

       liString=person.toString();

       System.out.println( "将集合转换为字符串:" +liString);

        

       //将集合转换为数组，默认类型

       System.out.println( "将集合转换为数组:" +person.toArray());

        

       将集合转换为指定类型（友好的处理）

       //1.默认类型

       List<Object> listsStrings= new ArrayList<>();

       for ( int i = 0 ; i < person.size(); i++) {

         listsStrings.add(person.get(i));

       }

       //2.指定类型

       List<StringBuffer> lst= new ArrayList<>();

       for (String string:person){

         lst.add(StringBuffer(string));

       }

        

        

        

        

   }

  

   private static StringBuffer StringBuffer(String string) {

     return null ;

   }

  

  

   }