0718 try-catch自定义异常/ArrayList/HashSet 迭代器 HashMap Set/字符数量排序 Entry Conllections/ArrayList排序

异常的处理
抛出:抛给异常发生代码的调用者
捕获：
try{
//异常可能发生的代码
}catch(Exception e){//e是异常的引用
e.printStackTrace();//打印异常堆栈信息
}finally{
//不论异常发生与否，都必须执行的代码
//一般用来释放资源
}
自定义异常(针对具体业务逻辑)
案例:年龄异常案例

集合框架
数组的缺陷
数组一旦创建，长度就不可改变
数组存储的数据必须是同一类型
数组只能存储数据,没有封装对数据的操作

集合
单列数据(Collection)
List :有索引维护,有序,数据可以重复
ArrayList:线性表(理解为一个动态数组)
LinkedList:链表
set :没有索引维护，无序,数据不可重复
注意：存放在set中对象必须实现equals()方法和hashCode方法

双列数据(键值对,Map)
HashMap 是在HashSet的基础上构建的
key --- value
key 不能重复的,如果重复后一个键值对会将前一个覆盖掉
"tom"---"789"
"jack"---"456"
如何保证key不会重复,key对象必须实现equals()方法和hashCode()方法

ArrayList LinkedList HashMap HashSet
案例:集合排序
统计字符个数，再排序
从控制台输入一个字符串
you can you up
y:2
o:2
u:3
....

迭代器与增强for循环

try-catch自定义异常

package demo07;

public class Demo01 {
	/**
	 * 3.编写程序，实现从命令行输入三个数值参数作为三角形的三条边，以此构造一个三角形。
  程序应该实现如下功能：
?检查用户输入的命令行参数是否足够，如果不够三个参数，
则程序可能产生ArrayIndexOutOfBoundsException异常。
?检查输入的命令行参数是否为数值格式，如果输入的数值参数格式错误，
则程序可能产生NumberFormatException异常。
?检查输入的命令行参数中是否有负值或0，如果有负值或0，
则程序可能产生IllegalArgumentException异常。
?检查输入的命令行参数的三个数值是否能够构造一个三角形，
如果不能构造一个三角形，则程序可能产生InvalidEdgesException异常
（InvalidEdgesException异常为用户自定义异常）。
	 * @param args
	 */
     public static void main(String[] args) {           
			try {
				float a = Float.parseFloat(args[0]);
				float b = Float.parseFloat(args[1]);
				float c = Float.parseFloat(args[2]);
				if(a<=0 || b<=0 || c<=0){
					 throw new IllegalArgumentException("三角形的边长不能为负数或者0");
				}
				
				if(a+b<=c || a+c <=b || b+c <=a){
					 throw new InvalidEdgesException("三角形任意两边之和大于第三边");
				}
				
			} catch (NumberFormatException e) {
				e.printStackTrace();
			}catch(ArrayIndexOutOfBoundsException e){
				e.printStackTrace();
			}catch(IllegalArgumentException e){
				 e.printStackTrace();
			}catch(InvalidEdgesException e){
				  e.printStackTrace();
			}

	
     
     }
}
class InvalidEdgesException extends RuntimeException{
	
	   public InvalidEdgesException(String msg){
		     super(msg);
	   }
}

ArrayList

package demo07;

import java.util.ArrayList;

import demo06.Employee;

public class Demo02 {
   public static void main(String[] args) {
	   //Arraylist中存放的是对象
	   ArrayList list = new ArrayList();
	   list.add(12);
	   list.add("java");
	   list.add(new Employee());
	   //遍历集合
	   // size() --获得集合中对象的数量
	   for (int i = 0; i < list.size(); i++) {
		           Object o= list.get(i);
		           System.out.println(o);
	  }
	   //删除集合中的对象
	   //通过索引删除
	   list.remove(0); //删除12
	   list.remove("java");//直接用对象做参数
	   System.out.println(list.size());
	   System.out.println(list.get(0));
	   
  }
}

package demo07;

import java.util.ArrayList;

public class Demo03 {
   public static void main(String[] args) {
	    ArrayList list = new ArrayList();
	    list.add(1);
	    list.add(2);
	    list.add(5);
	    list.add(6);
	    list.add(7);
	    list.add(8);
	    System.out.println(list.size());//8
	    //使用循环语句删除这个集合      
//	    for (int i = 0; i < list.size(); i++) {
//			  list.remove(i);
//		}
//	    for (int i = list.size()-1; i>=0; i--) {
//			list.remove(i);
//		}
	    for (; list.size()>0; ) {
			   list.remove(0);
		}
	    
	    System.out.println(list.size());//0
   }
}

package demo07;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo04 {
    /**
     * 泛型
     */
	public static void main(String[] args) {
		 //这个list集合中只能存放Employee类型
		  List<Employee> es = new ArrayList<Employee>();
		   es.add(new Employee());
		  // Iterator<Employee> iterator = es.iterator();
		  
	}
}

package demo07;

public class Employee {
	//私有的成员变量
     private int id;
     private String name;
     private String sex;
     private int age;
     private float salary;
     private String dept;
     //空参的构造方法
     public Employee() {
    	 super();
    	 // TODO Auto-generated constructor stub
     }

	//有参的构造方法
     public Employee(int id, String name, String sex, int age, float salary, String dept) {
    	 super();
    	 this.id = id;
    	 this.name = name;
    	 this.sex = sex;
    	 this.age = age;
    	 this.salary = salary;
    	 this.dept = dept;
     }

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public float getSalary() {
		return salary;
	}
	public void setSalary(float salary) {
		this.salary = salary;
	}
	public String getDept() {
		return dept;
	}
	public void setDept(String dept) {
		this.dept = dept;
	}
     
	//展示员工信息
	public void printInfo(){
		  System.out.println(id+","+name+","+sex+","+age+","+salary+","+dept);
	}
     
	//加薪
	public void addSalary(float salary){
		 this.salary += salary;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((dept == null) ? 0 : dept.hashCode());
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + Float.floatToIntBits(salary);
		result = prime * result + ((sex == null) ? 0 : sex.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (dept == null) {
			if (other.dept != null)
				return false;
		} else if (!dept.equals(other.dept))
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Float.floatToIntBits(salary) != Float.floatToIntBits(other.salary))
			return false;
		if (sex == null) {
			if (other.sex != null)
				return false;
		} else if (!sex.equals(other.sex))
			return false;
		return true;
	}
}

HashSet 迭代器 HashMap Set

package demo07;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Demo05 {
   public static void main(String[] args) {
	   Set<String> sets =  new HashSet<String>();
	   /*
	    * 因为String类型重写了Object类的
	    * equals()方法和hashCode()方法
	    * 所以能够存放在HashSet中实现去重效果
	    * 其他类型也是这样
	    */
	    sets.add("java");
	    sets.add(".net");
	    System.out.println(sets.size());
	    sets.add("Java");
	    System.out.println(sets.size());

        for(String s:sets){
        	 System.out.println(s);
        }
	    /*
	    Iterator<String> it = sets.iterator();
	    while(it.hasNext()){
	    	  String str = it.next();
	    	  System.out.println(str);
	    	  //it.remove();
	    }*/
	    
   }
}

package demo07;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo06 {
   public interface Aoo{
	     public interface Boo{}
	   
   }
	 /**
	  *   HashMap
	  * @param args
	  */
    public static void main(String[] args) {
    	 //创建map对象
		 Map<String,Integer> map = new HashMap<String,Integer>();
		 //向map中添加数据 key-value
		 map.put("java", 1);
		 map.put("c/c++",2 );
		 map.put(".net", 3);
		 map.put("php", 4);
		 map.put("javascript", 5);
		 System.out.println(map.size());
		 map.put("java",66);
		 System.out.println(map.size());
		 //删除 通过key来删除整个键值对
		 map.remove(".net");
		 System.out.println(map.size());
		 //遍历map
		 //keySet()将map中所有的key封装成一个set集合
		 Set<String> sets = map.keySet();
		 for(String key:sets){
			    // get(key)  通过key获得value
			    Integer value = map.get(key);
			    System.out.println(key+":"+value);
		 }
		 System.out.println("------------------------------------");
		 //遍历2 Entry<String, Integer> 
		 // Entry就是键值对类型
		 // 将所有key--value封装成set
		  Set<Entry<String, Integer>> entrySet = map.entrySet();
		  for(Entry<String, Integer> ey:entrySet){
			   System.out.println(ey.getKey()+":"+ey.getValue());
		  }
		 
	}
}

字符数量排序 Entry Conllections

package demo07;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Demo07 {
    public static void main(String[] args) {
		   Scanner sc = new Scanner(System.in);
		   System.out.print("请输入一个字符串:");
		   String str = sc.nextLine();
		   //将str转换成一个字符数组
		   char[] chs = str.toCharArray();
		   //将字符数组中的元素放入hashmap中
		   // 'y'-- 2  'o'--2  'u'--3  ' '---4
		   Map<Character,Integer> map = new HashMap<Character,Integer>();
		   //遍历数组chs
		   //['y','o','u',' ','c','a',...]
		   for (int i = 0; i < chs.length; i++) {
			        Integer num = map.get(chs[i]);
			        if(num==null){
			        	 //第一次遇到这个字符
			        	 map.put(chs[i], 1);
			        }else{
			        	//不是第一次遇到这个字符
			        	map.put(chs[i],num+1);
			        }
		   }
		   System.out.println(map);
		   //遍历map
		   Set<Character> keys = map.keySet();
		   for(Character c:keys){
			    System.out.println(c+":"+map.get(c));
		   }
	}
}

package demo07;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

public class Demo09 {
     public static void main(String[] args) {
    	 Scanner sc = new Scanner(System.in);
		   System.out.print("请输入一个字符串:");
		   String str = sc.nextLine();
		   //将str转换成一个字符数组
		   char[] chs = str.toCharArray();
		   //将字符数组中的元素放入hashmap中
		   // 'y'-- 2  'o'--2  'u'--3  ' '---4
		   Map<Character,Integer> map = new HashMap<Character,Integer>();
		   //遍历数组chs
		   //['y','o','u',' ','c','a',...]
		   for (int i = 0; i < chs.length; i++) {
			        Integer num = map.get(chs[i]);
			        if(num==null){
			        	 //第一次遇到这个字符
			        	 map.put(chs[i], 1);
			        }else{
			        	//不是第一次遇到这个字符
			        	map.put(chs[i],num+1);
			        }
		   }
		   System.out.println(map);
		   //遍历map
		   Set<Character> keys = map.keySet();
		   for(Character c:keys){
			    System.out.println(c+":"+map.get(c));
		   }
		   System.out.println("-------------------------------------");
		   //排序
		   //将map ---> list
		   Set<Entry<Character, Integer>> set = map.entrySet();
		   List<Entry<Character, Integer>> list 
		       = new ArrayList<Entry<Character, Integer>>(set);
		   Collections.sort(list, new NumComparator());
		   for(Entry<Character, Integer> ey:list){
			     System.out.println(ey.getKey()+":"+ey.getValue());
		   }
	}
}
class NumComparator implements Comparator<Entry<Character, Integer>>{

	@Override
	public int compare(Entry<Character, Integer> ey1, Entry<Character, Integer> ey2) {
		// 'y' - 2
		return ey2.getValue() - ey1.getValue();
	}
	
}

ArrayList排序

package demo07;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo08 {
	//集合排序
    public static void main(String[] args) {
		 List<Integer> list = new ArrayList<Integer>();
		 list.add(33);
		 list.add(8);
		 list.add(56);
		 list.add(89);
		 list.add(2);
		 //排序前的状态
		 for(Integer i:list){
			  System.out.println(i);
		 }
		 Collections.sort(list, new MyComparator());//回调用模式
		 System.out.println("---------------------------");
		 //排序后的状态
		 for(Integer i:list){
			  System.out.println(i);
		 }
	}

}
class MyComparator implements Comparator<Integer>{
   /**
    *  num1 和 num2是集合中相邻的两个对象
    *  在排序的时候这两个会做比较以确定
    *  谁先谁后 (自然顺序 num1 num2)
    *   如果返回值>0  num1 和 num2就交换位置
    *   如果返回值<=0  保持原来的位置
    *  
    */
	@Override
	public int compare(Integer num1, Integer num2) {
		// 12 6 45  3 78
		return -(num1  - num2);
	}
	
}

0718 try-catch自定义异常/ArrayList/HashSet 迭代器 HashMap Set/字符数量排序 Entry Conllections/ArrayList排序

猜你喜欢