包装类
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类 |