异常的处理
抛出:抛给异常发生代码的调用者
捕获:
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);
}
}