Java简明总结(四)

包装类

package cn.com.oneqinglong.IntegerDemo;
/**
 * 
 * @author oneqinglong
 *
 *
 *int和Integer的区别:
 *
 *  int是基本数据类型 Integer是java机制为int提供的包装类(封装类)
 *
 *  int类型的默认值是:0  Integer类型的默认值:null
 *
 *我们就以int和Integer以及String类型为例 讲解基本数据类型 包装类和String类型之间进行转换
 *
 *
 */
public class IntegerDemo {

    public static void main(String[] args) {
        //把int类型转换为Integer类型
        int a=10;
        Integer ir=new Integer(a);
        System.out.println(ir);
        //把Integer类型转换为int类型
        Integer ir2=new Integer(30);
        int b=ir2.intValue();
        System.out.println(b);
        //把String类型转换为Integer类型
        //java.lang.NumberFormatException 数字格式化异常
        String s="123";
        Integer ir3=new Integer(s);
        System.out.println(ir3+1);
        //把Integer类型转换为String类型
        Integer ir4=new Integer(50);
        String c=ir4.toString();
        System.out.println(c+1);
        //把int类型转换为String类型
        int d=12;
        String s2=String.valueOf(d);
        System.out.println(s2+1);
        //把String转换为int类型
        String s4="234";
        int x=Integer.parseInt(s4);
        System.out.println(x+1);
    }
}

总结： 1. int–>Integer: new对象时候传入int值。 2.Integer–>: 使用Integer对象的intValue()方法。 3. String–>Integer: new对象的时候传入String值。 4. Integer–>String: 使用Integer对象的toString()方法。 5. int–>String: 使用String对象的valueOf方法。 6.String–>int: 使用Integer对象的parseInt()方法。

---

package cn.com.oneqinglong.IntegerDemo;
/**
 * 
 * @author oneqinglong
 *
 *自动装箱和自动拆箱技术是jdk1.5之后出现的新技术
 *
 *
 */
public class IntegerDemo2 {

    public static void main(String[] args) {

        int a=20;
        //自动装箱
        Integer ir=a;//Integer ir=new Integer(a);
        //自动拆箱
        int c=ir+3;//int c=ir.intValue()+3;
        System.out.println(c);
    }
}

---

package cn.com.oneqinglong.CharacterDemo;
/**
 * 
 * @author oneqinglong
 *
 *Character类中常用的方法:
 *
 *boolean isDigit(char c);功能:判断指定的字符是否为数字
 *
 *boolean isLetter(char c);功能:判断指定的字符是否为字母
 *
 *boolean isLetterOrDigit(char c);功能:判断指定的字符是否为数字或者字母
 *
 *boolean isLowerCase(char c);功能:判断指定的字符是否为小写字母
 *
 *boolean isUpperCase(char c);功能:判断指定的字符是否为大写字母
 *
 *
 */
public class CharacterDemo {

    public static void main(String[] args) {
        //判断指定的字符是否为数字
        boolean bn=Character.isDigit('f');
        System.out.println(bn);
        //判断指定的字符是否为字母
        boolean bm=Character.isLetter('e');
        System.out.println(bm);
        //判断指定的字符是否为字母或者数字
        boolean x=Character.isLetterOrDigit('号');
        System.out.println(x);
        //判断指定的字符是否为小写
        boolean y=Character.isLowerCase('F');
        System.out.println(y);
        //判断指定的字符是否为大写字母
        boolean z=Character.isUpperCase('T');
        System.out.println(z);
    }
}

总结: 1. Character.isDigit() 2. Character.isLetter() 3. Character.isLetterOrDigit 4. Character.isLowerCase() 5. Character.isUpperCase()

---

package cn.com.oneqinglong.Zuoye3;
/**
 * 
 * @author oneqinglong
 *
 *需求:校验用户名和密码:
 *
 *在注册时通常要验证用户名和密码是否合法，运用学习过的知识完成如下操作：
    用户名长度大于等于6位，必须包含数字和英文字母
    密码长度大于等于8位，必须包含特殊符合_或者$，英文字母以及数字
    *
    *方法一:完成成校验用户名或者密码是否包含数字以及英文字母
    *
    *方法二:判断用户名是否合法
    *
    *方法三:判断密码是否合法
    *
 */
public class Zuoye3 {

    /**
     * 功能:校验用户名或者密码 是否包含数字以及英文字母
     * @param str 待校验的用户名或者密码
     * @return 校验后的结果
     */
    public boolean con(String str){

        boolean bn=false;//用来标记数字
        boolean bm=false;//用来标记字母
        //把字符串转换为char数组
        char[] array=str.toCharArray();
        //遍历数组
        for (int i = 0; i < array.length; i++) {

            //判断是否包含数字
            if(Character.isDigit(array[i])){

                bn=true;
                break;
            }
        }


        //遍历数组 判断是否包含英文字母
        for (int i = 0; i < array.length; i++) {

            //判断是否包含字母
            //if(Character.isLetter(array[i])){}
            if(array[i]>='a' && array[i]<='z' || array[i]>='A' && array[i]<='Z'){

                bm=true;
                break;

            }

        }

        if(bn&&bm==true){

            return true;
        }

        return false;
    }


    /**
     * 功能:校验用户名是否合法
     * @param userName 待校验的用户名
     * @return 校验的结果
     */
    public boolean conUserName(String userName){

        //判断用户名的长度是否合法
        if(userName.length()>=6){

            //判断是否包含数字以及英文字母
            if(con(userName)){

                return true;
            }
        }
        return false;
    }


    /**
     * 功能:判断密码是否合法
     * @param password 待校验的密码
     * @return 校验的结果
     */
    public boolean conPassword(String password){
        //判断密码的长度是否合法
        if(password.length()>=8){

            //判断是否包含下划线
            boolean a=password.contains("_");
            //判断是否包含美元符号
            boolean b=password.contains("$");
            //判断是否包含数字以及英文字母
            boolean c=con(password);

            if((a||b) && c){

                return true;
            }
        }
        return false;
    }
}

package cn.com.oneqinglong.Zuoye3;

import java.util.Scanner;

public class Test {

    public static void main(String[] args) {

        Scanner scr=new Scanner(System.in);
        System.out.println("请输入用户名:");
        String userName=scr.next();
        System.out.println("请输入密码:");
        String password=scr.next();

        Zuoye3 zy=new Zuoye3();

        boolean bn=zy.conUserName(userName);
        boolean bm=zy.conPassword(password);

        if(bn&&bm){

            System.out.println("注册成功");
        }else{

            System.out.println("注册失败");
        }
    }
}

---

Math类

package cn.com.oneqinglong.MathDemo;
/**
 * 
 * @author oneqinglong
 *
 *Math类中常用的方法:
 *
 *int abs(int a);功能:返回该数值的绝对值
 *
 *double max(double a,double b);功能:返回两个数中较大的一个
 *
 *int min(int a,int b);功能:返回两个数中较小的一个
 *
 *double pow(int a,int b);功能:求a的b次方
 *
 *double random();功能:产生0.0到1.0之间的随机数  其中包括0.0 不包括1.0
 *
 *double round(double a);功能:四舍五入
 *
 */
public class MathDemo {

    public static void main(String[] args) {
        //返回该数值的绝对值
        int a=Math.abs(-20);
        System.out.println(a);
        //返回两个数中较大的一个
        int b=Math.max(10, 30);
        System.out.println(b);
        //返回两个数中较小的一个
        int c=Math.min(20, 10);
        System.out.println(c);
        //求第一个数的 第二个数次方法
        double f=Math.pow(3, 5);
        System.out.println(f);
        //产生0.0到1.0之间的随机数
        double d=Math.random();
        System.out.println(d);
        //四舍五入
        double z=Math.round(2.5);
        System.out.println(z);
    }
}

随机数

package cn.com.oneqinglong.RandomDemo;

import java.util.Random;

/**
 * 
 * @author oneqinglong
 *
 *
 *boolean nextBoolean();功能:随机产生一个boolean值
 *
 *double nextDouble();功能:在 0.0 和 1.0 之间均匀分布的 double 值。
 *
 */
public class RandomDemo {

    public static void main(String[] args) {

        Random rd=new Random();
        //随机产生一个boolean类型
        boolean bn=rd.nextBoolean();
        System.out.println(bn);
        //随机产生一个double型的数值  0.0到1.0之间
        double a=rd.nextDouble();
        System.out.println(a);
        float b=rd.nextFloat();
        System.out.println(b);
        int c=rd.nextInt();
        System.out.println(c);
        int d=rd.nextInt(100);
        System.out.println(d);

    }
}

总结： 1. Math.abs(a); 2. Math.max(a,b); 3. Math.min(a,b); 4. Math.pow(a,b); 5. Math.random(); 6. Math.round(a);

---

Date类–时间类

package cn.com.oneqinglong.DateDemo;

import java.util.Date;

/**
 * 
 * @author oneqinglong
 *
 *java.util.Date类表示特定的瞬间 可以精确到毫秒
 *
 *Date类中常用的方法:
 *
 *long getTime();功能:返回自1970年1月1日 00:00:00以来的毫秒值
 *
 *boolean after(When w);功能:测试此日期是否在指定日期之后
 *
 *boolean before(When w);功能:测试此日期是否在指定日期之前
 *
 *void setTime(long t);功能:根据毫秒之设置时间
 *
 */
public class DateDemo {

    public static void main(String[] args) {
        //获取当前系统时间
        Date d=new Date();
        System.out.println(d);

        long t=d.getTime();
        System.out.println(t);
        //根据毫秒值 获取时间
        Date d2=new Date(1489627959917L);
        System.out.println(d2);
        //测试此日期是否在指定日期之后
        boolean bn=d.after(d2);
        System.out.println(bn);
        //测试此日期是否在指定日期之前
        boolean bm=d2.before(d);
        System.out.println(bm);
        //根据毫秒之设置时间
        d.setTime(1489627959917L);
        System.out.println(d);
    }
}

总结: 1. getTime() 2. setTime()

Calendar类–日期类

package cn.com.oneqinglong.CalendarDemo;

import java.util.Calendar;
import java.util.GregorianCalendar;

/**
 * 
 * @author oneqinglong
 *
 *java.util.Calendar类表示日历类
 *
 */
public class CalendarDemo {

    public static void main(String[] args) {
        //获取Calendar对象
        Calendar c=Calendar.getInstance();
        System.out.println(c);
        //获取年份
        int y=c.get(Calendar.YEAR);
        System.out.println(y);
        //获取月份
        int month=c.get(Calendar.MONTH);
        System.out.println(month);
        //获取日期
        int d=c.get(Calendar.DAY_OF_MONTH);
        System.out.println(d);
        int s=c.get(Calendar.DAY_OF_YEAR);
        System.out.println(s);

        GregorianCalendar gc=new GregorianCalendar();
        //判断是否是闰年
        boolean bm=gc.isLeapYear(2010);
        System.out.println(bm);
    }
}

总结： 1. Calendar.getInstance(); 2. c.get(Calendar.YEAR); 3. c.get(Calendar.MONTH); 4.c.get(Calendar.DAY_OF_MONTH); 5. c.get(Calendar.DAY_OF_YEAR); 6. new GregorianCalendar().isLeapYear

---

DateFomat类

package cn.com.oneqinglong.DateFromatDemo;

import java.text.DateFormat;
import java.util.Date;

public class DateFromatDemo {

    public static void main(String[] args) {

        //获取格式器 默认风格
        DateFormat df=DateFormat.getDateInstance();
        Date d=new Date();
        //格式化日期
        String s=df.format(d);
        System.out.println(s);
        //获取格式器 指定FULL风格
        DateFormat df2=DateFormat.getDateInstance(DateFormat.FULL);
        String s2=df2.format(d);
        System.out.println(s2);
        //获取格式器 指定SHORT风格
        DateFormat df3=DateFormat.getDateInstance(DateFormat.SHORT);
        String s3=df3.format(d);
        System.out.println(s3);
        //获取格式器 指定LONG风格
        DateFormat df4=DateFormat.getDateInstance(DateFormat.LONG);
        String s4=df4.format(d);
        System.out.println(s4);
        //获取格式器指定MEDIUM风格
        DateFormat df5=DateFormat.getDateInstance(DateFormat.MEDIUM);
        String s5=df5.format(d);
        System.out.println(s5);
    }
}

SimpleDateFormat类

Date变成String

package cn.com.oneqinglong.SimpleDateFormatDemo;

import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {

    public static void main(String[] args) {

        Date d=new Date();

        //建立格式器 默认风格
        SimpleDateFormat sdf=new SimpleDateFormat();
        String s=sdf.format(d);
        System.out.println(s);
        //建立格式器 指定风格
        SimpleDateFormat sdf2=new SimpleDateFormat("yyyy--MM--dd");
        String s2=sdf2.format(d);
        System.out.println(s2);
        //建立格式器 指定风格
        SimpleDateFormat sdf3=new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss SSS Z");
        String s3=sdf3.format(d);
        System.out.println(s3);
    }
}

String解析称Date

package cn.com.oneqinglong.SimpleDateFormatDemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFromatDemo2 {

    /**
     * 
     * @param args
     * @throws ParseException 解析异常
     * 
     * 解析的过程中:解析模式 必须和待解析字符串的模式一模一样 否则就会报出java.text.ParseException 解析异常
     */
    public static void main(String[] args) throws ParseException {

        String str="2017年3月16日";

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");
        //java.text.ParseException 解析异常
        Date d=sdf.parse(str);
        System.out.println(d);
    }
}

总结: 1. new SimpleDateFormat().format(); 2. new SimpleDateFormat().parse();

DecimalFormat类–Number格式化

int格式化称String

package cn.com.lingyao.DecimalFormatDemo;

import java.text.DecimalFormat;

public class DecimalFormatDemo {

    public static void main(String[] args) {

        int a=123456;
        //默认风格
        DecimalFormat df=new DecimalFormat();
        String s=df.format(a);
        System.out.println(s);

        DecimalFormat df2=new DecimalFormat("###,###.00");
        String s2=df2.format(a);
        System.out.println(s2);
        //格式化为百分数
        DecimalFormat df3=new DecimalFormat("###,###.00%");
        String s3=df3.format(a);
        System.out.println(s3);
        //格式化为人民币
        DecimalFormat df4=new DecimalFormat("###,###.00¤");
        String s4=df4.format(a);
        System.out.println(s4);
    }
}

String解析成int

package cn.com.lingyao.DecimalFormatDemo;

import java.text.DecimalFormat;
import java.text.ParseException;

public class DecimalFormatDemo2 {

    public static void main(String[] args) throws ParseException {

        String s="12345";
        DecimalFormat df=new DecimalFormat();
        Number a=df.parse(s);
        System.out.println(a.intValue()+1);

        String s2="12345.00%";
        DecimalFormat df2=new DecimalFormat("###,###.00%");
        Number n=df2.parse(s2);
        System.out.println(n);
    }
}

总结: 1. new DecimalFormat(“###,###.00”).format(a); 2. new DecimalFormat().parse();

---

Exception类

运行时异常

package cn.com.RuntimeExceptionDemo;
/**
 * 
 * @author lingyao
 *
 *异常:Exception
 *
 *  异常是指程序在编译或者运行过程中可能出现的例外.
 *
 *错误:Error Err
 *
 *  错误是指恢复不是不可能 而是非常困难的一种严重问题.比如:内存溢出
 *
 *异常的分类:
 *
 *  1.运行时异常也称为未检查期异常 RuntimeException以及子类  就是程序在运行过程中出现的异常
 *
 *  运行时异常不必要进行处理 可以通过严密的逻辑思维分析 避免运行时异常的出现
 *
 *  常见的运行时异常:
 *
 *  1.java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
 *
 *  2.java.lang.ArithmeticException 算术异常
 *
 *  3.java.lang.ClassCastException 类型转换异常
 *
 *  4.java.lang.NullPointerException 空指针异常
 *
 *  2.编译期异常也称为检查期异常 是指程序在编译过程出现的异常 除了RuntimeException以及子类 
 *
 *  编译期异常必须进行处理 否则编译器要报出错误
 *
 *java机制为我们提供了两种处理编译期异常的机制:
 *
 *  1.抛异常
 *
 *      throws 异常类型{}
 *
 *  2.捉异常
 *
 *      try{
 *
 *          可能出现异常的程序语句;
 *
 *      }catch(异常类型 异常名){
 *
 *          异常处理的方案;
 *          e.printStackTrace();//输出异常信息
 *
 *      }finally{
 *
 *          无论异常是否发生 总会被执行的程序语句.
 *      
 *      }
 *
 *  final,finally,finalize()的区别:
 *
 *  final:最终的 不能被更改的
 *
 *      1.用final修饰的变量 可以看成常量
 *
 *      2.用final修饰的类 不能被子类继承
 *
 *      3.用final修饰的方法 不能被子类重写
 *
 *  finally:总是执行
 *
 *      finally跟在try catch之后 无论异常是否发生总会执行的程序语句
 *
 *  finalize();
 *  
 *  finalize()是java.lang.Object类中一个方法,当垃圾回收机制 回收垃圾对象时
 *
 *  会调用被会回收对象的此方法 重写此方法会节省空间,关闭文件...
 *
 *  
 */

运行时异常

public class ArrayIndexOutOfBoundsExceptionDemo {

    public static void main(String[] args) {

        int[] array=new int[5];
        System.out.println(array[5]);
    }
}

package cn.com.RuntimeExceptionDemo;

public class ClassCastExceptionDemo {

    public static void main(String[] args) {
        //向上转型
        Object o=new Integer(20);
        //向下转型
        Integer s=(Integer)o;
        System.out.println(s);
    }
}

package cn.com.RuntimeExceptionDemo;

public class ArithmeticExceptionDemo {

    public static void main(String[] args) {

        int a=10;
        System.out.println(a/2);
    }
}

package cn.com.RuntimeExceptionDemo;

public class NullPointerExceptionDemo {

    public static void main(String[] args) {

        String str="123";
        System.out.println(str.hashCode());
    }
}

编译时异常

package cn.com.lingyao.ParseExceptionDemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ParseExceptionDemo {

    public static void main(String[] args) {

        String str="2017年3月16日";
        SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM月dd日");

        Date d=null;
            try {
                d=sd.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }finally{

                System.out.println("无论异常是否发生 总会被执行语句");
            }

        System.out.println(d);
    }
}

自定义异常

package cn.com.oneqinglong.Student;
/**
 * 
 * 
 * @author oneqinglong
 *
 *继承自Exception的异常 是编译期异常
 */
public class AgeGT150Exception extends Exception{

    /**
     * 
     */
    private static final long serialVersionUID = 1L

package cn.com.oneqinglong.Student;
/**
 * 
 * @author oneqinglong
 *
 *继承自RuntimeException的异常 是运行时异常
 *
 */
public class AgeLT0Exception extends RuntimeException{

    /**
     * 序列id号  写几都可以,如果不写系统默认提供
     */
    private static final long serialVersionUID = 1L;

    public AgeLT0Exception(){}

    public AgeLT0Exception(int a){}

}

package cn.com.oneqinglong.Student;

public class Student {

    private String name;

    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {

        if(age<0){

            throw new AgeLT0Exception(age);

        }else if(age>150){

            try {
                throw new AgeGT150Exception();
            } catch (AgeGT150Exception e) {
                e.printStackTrace();
            }

        }else{
            this.age = age;

        }
    }


}

package cn.com.oneqinglong.Student;

public class TestStudent {

    public static void main(String[] args) {

        Student stu=new Student();
        stu.setName("张三");
        stu.setAge(151);

        System.out.println(stu.getAge());

    }
}

总结: 1. ArrayIndexOutOfBoundsException 2. ArithmeticException 3. ClassCastException 4. NullPointerException 5. ParseException 编译时异常 6. 自定义异常

---

collection集合

package cn.com.oneqinglong.CollectionDemo;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 
 * @author oneqinglong
 *
 *集合:集合用于存储 操作 传输和获取聚合的数据
 *
 *集合的特点:
 *
 *  1.集合的长度是可变的 
 *
 *  2.集合存储的都是对象
 *
 *  3.集合不能存储基本数据类型值
 *
 *C (create) D(delete) S select (R) reader U (update):增删改查
 *
 *Collection中的常用方法:
 *
 *  1.添加
 *
 *  boolean add(E e);功能:向集合中添加指定的元素
 *
 *  boolean addAll(C c);功能:向集合中添加c中包含的所有元素
 *
 *  2.删除:
 *
 *  void clear();功能:移除集合中所有的元素
 *
 *  boolean remove(E e);功能:移除集合中包含的指定元素
 *
 *  boolean removeAll(C c);功能:移除集合中包含的c中的所有元素
 *
 *  3.修改:子类中进行扩展
 *
 *  4.查询:
 *
 *  int size();功能:获取集合中的元素个数
 *
 *  Iterator iterator();功能:获取集合元素的工具
 *
 *  5.其他:
 *
 *  boolean contains(E e);功能:判断集合中是否包含指定的元素
 *
 *  boolean contains(C c);功能:判断集合中是否包含c中的所有的元素
 *
 *  boolean isEmpty();功能:判断集合中是否包含元素
 *
 *  Object[] toArray();功能:把集合转换为数组
 *
 */
public class CollectionDemo {

    public static void main(String[] args) {

        Collection coll=new ArrayList();
        //coll.add(1);//自动装箱
        //向集合中添加元素
        boolean bn=coll.add(new Integer(30));
        System.out.println(bn);
        coll.add(new Integer(10));
        coll.add(new Integer(40));
        coll.add(new Integer(100));
        coll.add(new Integer(23));

        System.out.println(coll);

        Collection c=new ArrayList();
        c.add(new Integer(12));
        //向集合中添加coll中包含的 所有元素
        c.addAll(coll);
        System.out.println(c);

        System.out.println(coll);
        //移除集合中的元素
        coll.remove(new Integer(30));
        System.out.println(coll);
        //获取集合中元素的个数
        int a=coll.size();
        System.out.println(a);
        //判断集合中是否包含指定的元素
        boolean bm=coll.contains(23);
        System.out.println(bm);
        //判断集合中是否包含元素
        boolean b=coll.isEmpty();
        System.out.println(b);

        //把集合转换为数组
        Object[] array=coll.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

List

package cn.com.oneqinglong.ListDemo;

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

/**
 * 
 * @author oneqinglong
 *
 *List集合是以列表的形式存储信息
 *
 *List集合的特点:
 *
 *  1.有序的.指的是添加元素和取出元素的顺序是一致的.即 先进先出 后进后出
 *
 *  2.允许元素重复的.
 *
 *  3.允许多个null元素
 *
 *List集合索引也是从0开始
 *
 *
 *1.添加:
 *
 *  boolean add(E e);功能:向列表的尾部添加指定的元素
 *
 *  void add(int index,E e);功能:向列表中指定的位置添加指定的元素
 *
 *  boolean addAll(C c);功能:向列表中添加c中包含的所有元素
 *
 *  boolean addAll(int index,C c);功能:向列表中指定的位置添加c中包含的所有元素
 *
 *2.删除:
 *
 *  void clear();功能:移除列表中所有的元素
 *
 *  E remove(int index);功能:根据索引移除列表中指定的元素
 *
 *  boolean remove(Object o);功能:移除列表中第一次出现的元素
 *
 *  boolean removeAll(C c);功能:移除列表中包含c中的所有元素
 *
 *  3.修改:
 *
 *  E set(int index,E e);功能:根据索引修改列表中的元素
 *
 *  4.获取:
 *
 *  int size();功能:获取列表中元素的个数
 *
 *  E get(int index);功能:根据索引获取列表中的元素
 *
 *  int indexOf(E e);功能:获取列表中第一次出现元素的索引 如果该元素不存在 则返回-1
 *
 *  int lastIndexOf(E e);功能:获取列表中最后一次出现元素的索引 如果该元素不存在 则返回-1
 *
 *
 *  5.其他:
 *
 *  boolean isEmpty();功能:判断列表中是否包含元素
 *
 *  boolean contains(E e);功能:判断列表中是否包含指定的元素
 *
 *  boolean containsAll(C c);功能:判断列表中是否包含c中所有的元素
 *
 *
 */
public class ListDemo {

    public static void main(String[] args) {
        //向上转型
        List list=new ArrayList();
        //向集合中添加元素
        list.add("一");
        list.add("二");
        list.add("三");
        list.add("四");
        list.add("五");
        list.add("一");
        list.add("二");
        list.add("一");

        System.out.println(list);
        //根据索引添加插入指定的元素
        list.add(1, "六");
        System.out.println(list);
        //根据索引移除列表中指定的元素
        Object obj=list.remove(1);
        System.out.println(obj);
        System.out.println(list);
        //移除列表中第一次出现的元素
        list.remove("一");
        System.out.println(list);
        //根据索引修改元素
        Object a=list.set(1, "七");
        System.out.println(a);
        System.out.println(list);
        //获取列表中元素的个数
        int b=list.size();
        System.out.println(b);
        //根据索引 获取元素
        Object ob=list.get(1);
        System.out.println(ob);
        //获取列表中第一次出现元素的索引 
        int c=list.indexOf("一");
        System.out.println(c);
        //获取列表中最后一次出现元素的索引
        int d=list.lastIndexOf("一");
        System.out.println(d);
        //判断列表中是否包含元素
        boolean bn=list.isEmpty();
        System.out.println(bn);
    }
}

ArrayList

package cn.com.oneqinglong.ArrayListDemo;

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

/**
 * 
 * @author oneqinglong
 *
 *ArrayList是数组列表的形式存储信息
 *
 *ArrayList是不同步的(不支持多线程技术)
 */
public class ArrayListDemo {

    public static void main(String[] args) {

        ArrayList list=new ArrayList();
        list.add(new Integer(20));
        list.add(new Integer(30));
        list.add(new Integer(40));
        list.add(new Integer(50));
        list.add(new Integer(12));
        list.add(new Integer(54));
        //第一种方式:通过迭代器
        Iterator it=list.iterator();
        while(it.hasNext()){//hashNext()判断有没有下一个元素可以迭代

            Object obj=it.next();
            System.out.println(obj);
        }

        System.out.println("***************");
        //第二种方式:使用索引获取元素 仅限于在此使用
        for(int a=0;a<list.size();a++){

            Object ob=list.get(a);
            System.out.println(ob);
        }

        System.out.println("***************");
        //第三种方式:使用增强for循环    for(返回值类型  变量名:容器名){}
        for(Object c:list){

            System.out.println(c);
        }

    }
}

LinkedList

package cn.com.oneqinglong.LinkedListDemo;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {

    public static void main(String[] args) {

        LinkedList list=new LinkedList();
        list.add(new Integer(20));
        list.add(new Integer(30));
        list.add(new Integer(40));
        list.add(new Integer(50));
        list.add(new Integer(12));
        list.add(new Integer(54));

        Iterator it=list.iterator();
        while(it.hasNext()){

            Object l=it.next();
            System.out.println(l);
        }

        System.out.println("**********");
        for(int a=0;a<list.size();a++){

            Object ob=list.get(a);
            System.out.println(ob);
        }
        System.out.println("**********");
        for(Object s:list){

            System.out.println(s);
        }
    }
}

Set

HashSet

package cn.com.oneqinglong.HashSetDemo;

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

/**
 * 
 * @author oneqinglong
 *
 *Set是以哈希表支持 存储信息
 *
 *Set集合的特点:
 *
 *  1.无序的.指的是添加元素和取出元素的顺序是不一致的
 *
 *  2.不允许元素重复的
 *
 *  3.最多只允许一个null元素
 *
 *HashSet是不同步的
 */
public class HashSetDemo {

    public static void main(String[] args) {

        HashSet set=new HashSet();
        set.add(new Integer(10));
        set.add(new Integer(40));
        set.add(new Integer(12));
        set.add(new Integer(15));
        set.add(new Integer(17));
        int[] array={21,22,33,44,55};
        set.add(array);

        //使用迭代器
        Iterator it=set.iterator();
        while(it.hasNext()){

            Object ob=it.next();

            //判断是否是int类型的数组
            if(ob instanceof int[]){
                //向下转型
                int[] arr=(int[])ob;
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }

            }else{
            System.out.println(ob);
            }
        }
        System.out.println("*************");
        //增强for循环
        for(Object a:set){
            System.out.println(a);
        }
    }
}

TreeSet

package cn.com.oneqinglong.TreeSetDemo;

import java.util.Iterator;
import java.util.TreeSet;
/**
 * 
 * @author oneqinglong
 *
 *TreeSet是以二叉树的形式存储信息 (有自然排序的功能) 注意，此实现不是同步的
 *
 *用TreeSet存储自定义对象 需要实现Comparable重写comparTo方法
 *
 *
 */
public class TreeSetDemo {

    public static void main(String[] args) {

        TreeSet set=new TreeSet();
        set.add(new Student("201701", "张三", 25));
        set.add(new Student("201702", "李四", 29));
        set.add(new Student("201703", "王五", 23));
        set.add(new Student("201704", "赵六", 21));
        set.add(new Student("201705", "田七", 22));
        set.add(new Student("201706", "孙八", 27));
        set.add(new Student("201707", "白酒", 24));
        set.add(new Student("201708", "小明", 28));
        set.add(new Student("201709", "小强", 30));
        set.add(new Student("2017010", "小花", 22));

        Iterator it=set.iterator();
        while(it.hasNext()){

            Object obj=it.next();
            //判断一下对象是否是Student
            if(obj instanceof Student){

                Student stu=(Student)obj;
                System.out.println("学号:"+stu.getStuNo()+"--->姓名:"+stu.getName()+"--->年龄:"+stu.getAge());
            }
        }

    }
}

package cn.com.lingyao.TreeSetDemo;

public class Student implements Comparable{

    private String stuNo;//学号

    private String name;//姓名

    private int age;//年龄

    public Student(){}


    public Student(String stuNo, String name, int age) {

        this.stuNo = stuNo;
        this.name = name;
        this.age = age;
    }


    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    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 int compareTo(Object o) {

        Student stu=(Student)o;
        /*
         //升序排列
        if(this.age>stu.getAge()){

            return 2;
        }

        if(this.age<stu.getAge()){

            return -2;
        }
        */

        if(this.age>stu.getAge()){

            return -2;
        }

        if(this.age<stu.getAge()){

            return 2;
        }
        //降序排列
        /*
        if(stu.getAge()>this.age){

            return 2;
        }

        if(stu.getAge()<this.age){

            return -2;
        }
        */
        return this.name.compareTo(stu.getName());
    }


}

Map

package cn.com.oneqinglong.MapDemo;

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * @author oneqinglong
 *
 *Map集合特点:
 *
 *  1.Map集合是以键值对的形式存储信息
 *
 *  2.Map集合必须保证键的唯一性
 *
 *  3.Map集合一个键最多只能映射一个值
 *
 *  4.Map集合键一般情况下建议使用String类型
 *
 *  5.Map集合键重复 值覆盖
 *
 *  6.Map允许null键和null值
 *
 *  7.Map集合也称为双列集合
 *
 *
 *
 *
 *Map集合方法:
 *
 *  1.添加:
 *
 *      V put(K key,V value);功能:向集合中添加键值对
 *
 *      void putAll(Map m);功能:向集合中添加m中包括所有的键值对
 *
 *  2.删除:
 *
 *      V remove(K key);功能:根据键删除键值对
 *
 *      void clear();功能:移除集合中所有的键值对
 *
 *  3.修改:就是根据Map集合键重复 值覆盖的原理
 *
 *
 *  4.获取:
 *
 *      int size();功能:获取集合中键值对的个数
 *
 *
 *      V get(K key);功能:根据键获取值
 *
 *  5.其他:
 *
 *      boolean containsKey(K key);功能:判断集合中是否包含指定的键
 *
 *      boolean containsValue(V value);功能:判断集合中是否包含指定的值
 *
 *      boolean isEmpty();功能:判断集合中是否包含键值对
 *
 *
 *
 */
public class MapDemo {

    public static void main(String[] args) {
        Map map=new HashMap();
        //返回的是被添加之前的内容
        Object o=map.put("1", new Integer(10));
        System.out.println(o);
        map.put("2", new Integer(30));
        map.put("3", new Integer(40));
        map.put("4", new Integer(50));
        map.put("5", new Integer(50));

        Object obj=map.put("1", new Integer(12));
        System.out.println("obj="+obj);
        System.out.println(map);
        //根据键删除键值对   要根据键去找值  不要根据值去找键
        Object ob=map.remove("3");
        System.out.println(ob);
        System.out.println(map);
        //获取集合中键值对的个数
        int i=map.size();
        System.out.println(i);
        //根据键获取值
        Object a=map.get("1");
        System.out.println(a);
        //判断集合中是否包含指定的键
        boolean bn=map.containsKey("2");
        System.out.println(bn);
        //判断是否包含指定的值
        boolean bm=map.containsValue(30);
        System.out.println(bm);
    }
}

HashMap

package cn.com.oneqinglong.HashMapDemo;

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

/**
 * 
 * @author oneqinglong
 *
 *HashMap也是不同步的.
 *
 */
public class HashMapDemo {

    public static void main(String[] args) {

        HashMap m=new HashMap();
        m.put("一", new Integer(30));
        m.put("二", new Integer(10));
        m.put("三", new Integer(40));
        m.put("四", new Integer(12));
        //第一种方式:根据键获取值

        Set set=m.keySet();//获取集合中所有的键 返回的是Set集合
        //遍历set集合
        Iterator it=set.iterator();
        while(it.hasNext()){
            //获取键
            Object key=it.next();
            //根据键获取值
            Object value=m.get(key);
            System.out.println(key+"---->"+value);
        }

        System.out.println("********************");
        //第二种方式:根据Map集合的内部类接口Entry

        Set st=m.entrySet();//获取所有的Entry对象 Map集合中每个键值对都对应一个Entry对象
        for(Object obj:st){
            //向下转型
            Map.Entry en=(Map.Entry)obj;

            //获取键
            Object k=en.getKey();
            //获取值
            Object v=en.getValue();

            System.out.println(k+"--->"+v);
        }
    }
}

泛型技术

package cn.com.oneqinglong.ArrayListDemo;

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

/**
 * 
 * @author oneqinglong
 *
 *泛型技术是jdk1.5之后 出现的新技术
 *
 *集合一旦指定泛型 那么就只能存储指定泛型的数据
 *
 *
 */
public class ArrayListDemo {

    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();
        list.add("一");
        list.add("二");
        list.add("三");
        list.add("四");
        list.add("五");
        //第一种方式:使用迭代器
        Iterator<String> it=list.iterator();
        while(it.hasNext()){

            String s=it.next();
            System.out.println(s);
        }

        System.out.println("************");
        //第二种方式:通过索引
        for(int a=0;a<list.size();a++){

            String st=list.get(a);
            System.out.println(st);
        }
        System.out.println("************");
        //第三种方式:使用增强for循环
        for(String str:list){

            System.out.println(str);
        }
    }
}

package cn.com.oneqinglong.HashSetDemo;

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

public class HashSetDemo {

    public static void main(String[] args) {

        HashSet<Integer> set=new HashSet<Integer>();
        set.add(new Integer(10));
        set.add(new Integer(20));
        set.add(new Integer(30));
        set.add(new Integer(40));
        set.add(new Integer(50));
        //第一种方式:使用迭代器
        Iterator<Integer> it=set.iterator();
        while(it.hasNext()){

            Integer ir=it.next();
            System.out.println(ir);
        }
        System.out.println("************");
        //第二种方式:使用增强for循环
        for(Integer i:set){

            System.out.println(i);
        }
    }
}

package cn.com.oneqinglong.HashMapDemo;

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

/**
 * 
 * @author oneqinglong
 *
 *HashMap也是不同步的.
 *
 */
public class HashMapDemo {

    public static void main(String[] args) {

        HashMap m=new HashMap();
        m.put("一", new Integer(30));
        m.put("二", new Integer(10));
        m.put("三", new Integer(40));
        m.put("四", new Integer(12));
        //第一种方式:根据键获取值

        Set set=m.keySet();//获取集合中所有的键 返回的是Set集合
        //遍历set集合
        Iterator it=set.iterator();
        while(it.hasNext()){
            //获取键
            Object key=it.next();
            //根据键获取值
            Object value=m.get(key);
            System.out.println(key+"---->"+value);
        }

        System.out.println("********************");
        //第二种方式:根据Map集合的内部类接口Entry

        Set st=m.entrySet();//获取所有的Entry对象 Map集合中每个键值对都对应一个Entry对象
        for(Object obj:st){
            //向下转型
            Map.Entry en=(Map.Entry)obj;

            //获取键
            Object k=en.getKey();
            //获取值
            Object v=en.getValue();

            System.out.println(k+"--->"+v);
        }
    }
}

Collections类

package cn.com.oneqinglong.CollectionsDemo;

import java.util.ArrayList;
import java.util.Collections;

/**
 * 
 * @author oneqinglong
 *
 *java.util.Collections
 *
 *常用的方法:
 *
 *  void sort(List list);功能:升序排列列表中的数据
 *
 *  void shuffle(List list);功能:随机排序列表中的数据
 *  
 *  void reverse(List list);功能:反转排序列表中的数据
 *
 *  Object max(List list);功能:获取列表中最大的元素
 *
 *  Object min(List list);功能:获取列表中最小的元素
 *
 *
 */
public class CollectionsDemo {

    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        list.add(new Integer(20));
        list.add(new Integer(10));
        list.add(new Integer(12));
        list.add(new Integer(23));
        list.add(new Integer(45));
        System.out.println(list);
        //升序排列
        Collections.sort(list);
        System.out.println(list);
        //随机排序
        //Collections.shuffle(list);
        //System.out.println(list);
        //反转排序
        //Collections.reverse(list);
        //System.out.println(list);
        //获取列表中最大的元素
        Integer m=Collections.max(list);
        System.out.println(m);
        //获取列表中最小的元素
        Integer a=Collections.min(list);
        System.out.println(a);
        System.out.println(list);
        //使用二分查找 查找指定的元素
        int b=Collections.binarySearch(list, 21);
        System.out.println(b);
    }
}

Arrays类

package cn.com.oneqinglong.ArraysDemo;

import java.util.Arrays;

/**
 * 
 * @author oneqinglong
 *
 *java.util.Arrays
 *
 *常用的方法:
 *
 *  void sort(int[] arr);功能:升序排列数组中的元素
 *
 *
 */
public class ArraysDemo {

    public static void main(String[] args) {

        int[] arr={23,6,8,10,45};
        //升序排列
        //Arrays.sort(arr,0,3);
        /*
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        */

        int[] arr2=new int[10];
        Arrays.fill(arr2,2,5, 5);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        System.out.println("************");
        int[] arr3=Arrays.copyOfRange(arr, 0, 3);
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }
        System.out.println("************");
        int[] arr4=Arrays.copyOf(arr, 8);
        for (int i = 0; i < arr4.length; i++) {
            System.out.println(arr4[i]);
        }
    }
}

---

总结： 1. Collection 2. List：ArrayList, LinkedList 3. Set : HashSet, TreeSet 4. Map: HashMap 5. 泛型技术 6. Collections类 7. Arrays类