Day12
一、数组操作
1. 选择排序:
数组的0索引依次和后面的索引进行比较,对应的元素小的往前方法,依次比较,就可以得到一个排好序的数组
publicclass ArrayDemo {
public static void main(String[] args) {
//定义一个数组,静态初始化
int[] arr = {24,69,80,57,13};
//排序前
System.out.println("排序前:");
printArray(arr);
//调用
selectSort(arr);
System.out.println("排序后:");
printArray(arr);
}
//将选择排序的代码封装成一个独立的功能
public static void selectSort(int[] arr){
for(int x = 0;x < arr.length-1;x++){
for(int y = x +1;y<arr.length;y++){
//判断
if(arr[y]<arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
//遍历数组的功能
public static void printArray(int[] arr){
System.out.print("[");
//遍历数组
for(int x = 0;x < arr.length;x ++){
//判断是否最大索引
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else{
System.out.print(arr[x]+",");
}
}
}
}
2. 二分查找:针对数组一定有序的!
定义一个数组:11,22,33,44,55,66,77
解决思路:
1)定义最小索引和最大索引
2)计算出中间索引
3)拿中间索引对应的元素和要查找的元素进行比较
如果相等:直接返回中间索引
不相等:
大了,左边找
小了,右边找
4)重新获取最小索引和最大索引,计算出中间索引
5)回到3)继续查找
publicclass ArrayDemo {
public static void main(String[] args) {
//定义一个数组,静态初始化
int[] arr = {11,22,33,44,55,66,77};
//需求:查找33元素对应的索引
int index = getIndex(arr, 33);
System.out.println("index:"+index);
//需求:要查找333元素对应的索引
//如果查找的这个元素在数组中查不到呢?
int index2 = getIndex(arr, 333);
System.out.println("index2:"+index2);
}
public static int getIndex(int[] arr,intvalue){
//定义最大索引和最小索引
int max = arr.length -1;
int min = 0 ;
//计算中间索引
int mid = (max + min)/2;
//拿中间索引对应的元素和要查找的value元素进行比较
while(arr[mid] !=value){
//当前mid索引对应的元素不等于value元素,分两种情况
if(arr[mid]>value){
//重新获取最大索引
max = mid -1;
}else if(arr[mid]<value){
min = mid +1;
}
//如果找不到了应该返回-1
//判断
if(min>max){
return -1;
}
//重新获取最大和最小索引,计算中间索引
mid = (max+min)/2;
}
return mid ; //如果直接相等,直接返回
}
}
3. 假设有一个数组:int arr [24,69,80,57,13]
查找80这个元素在数组中的索引
将数组进行排序
冒泡排序
选择排序
注意:
现在得到这个索引已经发生变化了,由于排序,改变了原来是数组中元素的顺序,所以遇到这种情况,就不要使用二分查找,就是用最基本的查找方法(从头查到尾)
publicclass ArrayTest {
public static void main(String[] args) {
//定义一个数组
int[] arr ={24,69,80,57,13};
//首先对数组排序
selectSort(arr);
//排序后在查找
int index = getIndex(arr, 80);
System.out.println("index:"+index);
}
//选择排序
public static void selectSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ;x++){
for(int y = x +1 ;y<arr.length ;y++){
// 判断
if(arr[y]<arr[x]){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
//二分查找法
public static int getIndex(int[] arr,intvalue){
//定义最小索引和最大索引
int min = 0;
int max = arr.length -1;
//计算中间索引
int mid = (max+min)/2;
while(arr[mid]!= value){
if(arr[mid] > value){
//重新获取索引
//左边找
max = mid -1;
}else if(arr[mid]<value){
//右边找
min = mid +1;
}
//找不到返回-1
if(min >max){
return -1;
}
//重新计算中间索引
mid = (max +min)/2;
}
return mid;
}
//遍历数组
public static void printArray(int [] arr){
//输出左中括号
System.out.print("[");
for(int x = 0 ; x < arr.length ; x++){
if(x==arr.length -1){
System.out.println(arr[x]+"]");
}else{
System.out.print(arr[x]+",");
}
}
}
}
4.
Arrays:此类包含用来操作数组（比如排序和搜索）的各种方法(针对数组操作的工具类) 常用的几个方法:
public static String toString(int[] a):将任意类型的数组以字符串形式显示出来!
publicstatic void sort(int[] a):快速排序:(将给定数组中元素升序排序)
publicstatic int binarySearch(int[] a, int key):当前int数组一定是有序数组
使用二分搜索法来搜索指定的 int 型数组，以获得指定的值
publicclass ArraysDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {24,69,80,57,13};
//讲数组转成字符串的形式
System.out.println("toString():"+Arrays.toString(arr));
Arrays.sort(arr);
//在调用Arrays.toString(int[] a):将排好序的数组以String形式显示出来
System.out.println(Arrays.toString(arr));
//[13, 24, 57, 69, 80]
//public static int binarySearch(int[]a, int key)
//查找57元素在数组中的索引
int index = Arrays.binarySearch(arr, 57);
System.out.println("index:"+index);
//需求:查找577这个元素的索引
int index2 = Arrays.binarySearch(arr,577);
System.out.println("index2:"+index2);//-6
}
}
5. 字符串中的字符进行排序。
举例："dacgebf"
结果："abcde
改进:键盘录入一个字符串
publicclass ArrayTest {
public static void main(String[] args) {
//创建键录入对象
Scanner sc = new Scanner(System.in);
//录入并接收数据
System.out.println("请你输入一个字符串:");
String line = sc.nextLine();
//将字符串转换字符数组
char[] chs = line.toCharArray();
//给字符数组进行冒泡排序
bubbleSort(chs) ;
//最终要的是字符串,还需要将字符数组转换成字符串
String result = String.valueOf(chs);
System.out.println("result:"+result);
}
public static void bubbleSort(char[] chs){
for(int x = 0;x < chs.length-1;x ++){
for(int y = 0;y <chs.length-1-x;y++){
if(chs[y]>chs[y+1]){
//中间变量互换
char temp = chs[y];
chs[y] = chs[y+1];
chs[y+1] = temp;
}
}
}
}
}
二、Math类
Math类提供了一些数学运行的方法
常用的成员方法:
public static int abs(int a):绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static double max(double a,double b):获取最大值
public static double min(double a,double b):获取最小值
public static double pow(double a,double b):a的b次幂
public static double random():取值范围:[0.0,1.0)
public static long round(double a):四舍五入
public static double sqrt(double a):一个数的正平方跟
//importjava.util.Scanner;
//JDK5.0以后的新特性;
//importstatic java.lang.Math.abs; //静态导入()import static(该方法一定是静态方法)
publicclass MathDemo {
public static void main(String[] args) {
//System.out.println(Math.abs(-100));
System.out.println(java.lang.Math.abs(-100));
System.out.println(java.lang.Math.abs(-100));
//public static double ceil(double a):向上取整
System.out.println("ceil:"+Math.ceil(12.34));
System.out.println("ceil:"+Math.ceil(12.54));
//public static double floor(double a):向下取整
System.out.println("floor:"+Math.floor(12.34));
System.out.println("floor:"+Math.floor(12.56));
//public static double max(double a,doubleb):获取最大值
System.out.println("max:"+Math.max(Math.max(10,20),30));
//public static double pow(doublea,double b):a的b次幂
System.out.println("pow:"+Math.pow(2,3));
//public static long round(double a):四舍五入
System.out.println("round:"+Math.round(12.56));
//public static double sqrt(double a):一个数的正平方跟
System.out.println("sqrt:"+Math.sqrt(4));
}
}
三、System
1．System:该类没有构造方法,所以字段和成员方法都用静态修饰
常用的两个字段:
in,out都和流有关系:java.io...
PrintStream(字节打印流) ps = System.out ;标准输出流
PrintWriter(字符打印流)
InputStream in = System.in; 标准输入流
常用的成员方法:
public static void gc()运行垃圾回收器。
调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存,最终调用的就是重写之后finalize()回收不用的对象。
importjava.util.Scanner;
publicclass SystemDemo {
public static void main(String[] args) {
// Scanner sc = new Scanner(System.in) ;
// System.err.println("请您输入一个数据:");
// System.out.println("hello");
//创建Person类对象
Person p = new Person("高圆圆", 27);
System.out.println(p);
p = null ; //当前Person变成空了,没有更多的引用了
//启动垃圾回收器
System.gc();//当前垃圾回收器需要回收不用对象了Person [name=高圆圆, age=27]
}
}
publicclass Person {
//成员变量
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
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 String toString() {
return "Person [name=" + name+ ", age=" + age + "]";
}
//重写Object中的finalize()方法
@Override
protected void finalize() throws Throwable {
System.out.println("当前垃圾回收器需要回收不用对象了"+this);
super.finalize();
}
}
2．System:该类没有构造方法,所以字段和成员方法都用静态修饰
常用的两个字段:
in,out都和流有关系:java.io...
PrintStream(字节打印流) ps = System.out ; 标准输出流
PrintWriter(字符打印流)
InputStream in = System.in; 标准输入流
常用的成员方法:
public static void gc()运行垃圾回收器。
调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存,最终调用的就是重写之后finalize()回收不用的对象。
public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
public static longcurrentTimeMillis():返回当前的时间毫秒值
publicclass SystemDemo {
public static void main(String[] args) {
// long time = System.currentTimeMillis() ;//获取当前系统时间毫秒值
// System.out.println(time);
//currentTiimeMillis():单独使用没意义
//需求:计算某一个应用程序的耗时的毫秒数
long start = System.currentTimeMillis();
//for循环
for(int x = 0 ; x <100000;x ++){
System.out.println("hello"+x);
}
long end = System.currentTimeMillis();
System.out.println("当前for循环语句共耗时:"+(end-start)+"毫秒");//前for循环语句共耗时:4628毫秒
}
}
3.System里面的常用的成员方法:
public static void arraycopy(Object src,intsrcPos,Object dest, int destPos,int length)
指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束
publicclass SystemDemo2 {
public static void main(String[] args) {
//定义两数组,静态初始化
int[] arr1 = {11,22,33,44,55,66};
int[] arr2 = {3,4,5,6,7,8,9};
//复制数组
System.arraycopy(arr1, 2, arr2, 1, 2);
//分别将arr1 和arr2数组以字符串形式显示出来
System.out.println("arr1:"+Arrays.toString(arr1));
System.out.println("arr2:"+Arrays.toString(arr2));
}
}
四、BigInteger
1.BigInteger的构造方法
publicBigInteger(String val)将字符串表示的数字封装成BigInteger类型
成员方法:
public BigInteger add(BigInteger val)
public BigInteger subtract(BigIntegerval)
public BigInteger multiply(BigIntegerval)
public BigInteger divide(BigIntegerval)
public BigInteger[]divideAndRemainder(BigInteger val)
返回一个BigInteger数组,数组中的元素:商,余数
importjava.math.BigInteger;
publicclass BigIntegerDemo2 {
public static void main(String[] args) {
//创建BigInteger对象
BigInteger bg1 = newBigInteger("100");
BigInteger bg2 = newBigInteger("50");
//public BigInteger add(BigInteger val)
System.out.println("add:"+bg1.add(bg2));
//public BigInteger subtract(BigIntegerval)
System.out.println("sub:"+bg1.subtract(bg2));
//public BigInteger multiply(BigIntegerval)
System.out.println("mul:"+bg1.multiply(bg2));
//public BigInteger divide(BigIntegerval)
System.out.println("div:"+bg1.divide(bg2));
BigInteger[] datas =bg1.divideAndRemainder(bg2);
System.out.println("datas[0]:"+datas[0]);//2
System.out.println("datas[1]:"+datas[1]);//0
}
}
2.BigInteger:用来计算超出了Integer类型范围的数据
importjava.math.BigInteger;
publicclass BigIntegerDemo {
public static void main(String[] args) {
//查看Integer类的最大值
System.out.println(Integer.MAX_VALUE);//2147483647
//创建Integer对象
//Integer i= new Integer("2147483648");//java.lang.NumberFormatException: For input string: "2147483648"
//当前该数据已经超出了Integer的取值范围
//System.out.println(i);
BigInteger i = newBigInteger("2147483648");
System.out.println("i:"+i);
}
}
四、BigDecimal
1. 对于浮点类型的数据类说,他们存储和整数的存储是不一致的,是按照有效数字位来进行存储的,浮点类型的数据计算的时候
容易损失精度,计算出来的结果不精确,Java针对这种情况:提供了这个
BigDecimal:
作用:来提供浮点类型数据的精确计算!可变的、任意精度的有符号十进制数
构造方式:
public BigDecimal(String val)
publicclass BigDecimalDemo {
public static void main(String[] args) {
System.out.println(1.0-0.32);
System.out.println(0.01+0.09);
System.out.println(1.501*100);
System.out.println(1.031/100);
}
}
2.public BigDecimal(String val)
常用的成员方法;
public BigDecimal add(BigDecimalaugend):加
publicBigDecimal subtract(BigDecimal subtrahend):减
public BigDecimal multiply(BigDecimalmultiplicand):乘法
public BigDecimal divide(BigDecimaldivisor):除
参数1:商,参数2:保留几位小数,参数3:舍入的一种模式:ROUND_HALF_UP
importjava.math.BigDecimal;
publicclass BigDecimalDemo2 {
public static void main(String[] args) {
//创建BigDecimal对象
BigDecimal bd1 = newBigDecimal("0.01");
BigDecimal bd2 = newBigDecimal("0.09");
//public BigDecimal add(BigDecimalaugend):加
System.out.println("add:"+bd1.add(bd2));
BigDecimal bd3 = newBigDecimal("1.0");
BigDecimal bd4 = newBigDecimal("0.32");
//public BigDecimal subtract(BigDecimalsubtrahend):减
System.out.println("sub:"+bd3.subtract(bd4));//0.68
// publicBigDecimal multiply(BigDecimal multiplicand):乘法
BigDecimal bd5 = newBigDecimal("1.501");
BigDecimal bd6 = newBigDecimal("100.0");
System.out.println("mul:"+bd5.multiply(bd6));
//public BigDecimal divide(BigDecimaldivisor):除
BigDecimal bd7 = new BigDecimal("1.301");
BigDecimal bd8 = newBigDecimal("100");
System.out.println("div:"+bd7.divide(bd8));
//public BigDecimal divide(BigDecimaldivisor,int scale,int roundingMode)
//参数1:商, 参数2:保留几位小数,参数3:舍入的一种模式:ROUND_HALF_UP
System.out.println("div:"+bd7.divide(bd8,3, BigDecimal.ROUND_HALF_UP));
System.out.println("div:"+bd7.divide(bd8,8, BigDecimal.ROUND_HALF_UP));
}
}
六、Calendar
1.Calendar:日历类:
Calendar类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
Calendar该类是一个抽象类:不能实例化的,所以通过一下这个方法来创建对象
publicstatic Calendar getInstance()
publicint get(int field)返回给定日历字段的值
publicstatic final int YEAR:表示日历中 的年
public static final int MONTH:月份:是0开始计算的
public static final int DATE:和DAY_OF_MONTH是同义词,表示月份中的某天
importjava.util.Calendar;
publicclass CalendarDemo {
public static void main(String[] args) {
// 创建日历类对象
Calendar calendar =Calendar.getInstance();
//创建日历类对象,需要通过getInstance()方法创建对象
// 获取年
// public static final int YEAR
int year = calendar.get(Calendar.YEAR);
// 获取:年中的月份
// public static final int MONTH
int month =calendar.get(Calendar.MONTH);
// 获取月份中的天
// public static final int DATE
int date = calendar.get(Calendar.DATE);
//输出
System.out.println(year+"年"+(month+1)+"月"+date+"日");
}
}
2.Calendar常用的成员方法:
public abstract void add(int field,int amount)
为给定的日历的字段添加或者减去时间偏移量
public final void set(int year,int month,intdate)
设置日历字段 YEAR、MONTH 和DAY_OF_MONTH 的值
importjava.util.Calendar;
publicclass CalendarDemo2 {
public static void main(String[] args) {
//创建日历类对象
Calendar c = Calendar.getInstance();
//获取年
int year = c.get(Calendar.YEAR);
//获取月
int month = c.get(Calendar.MONTH);
//获取月中的天
int date = c.get(Calendar.DATE);
System.out.println(year+"年"+(month+1)+"月"+date+"日");
//需求:三年前的今天
//public abstract void add(int field,intamount)
//c.add(Calendar.YEAR, -3);
//获取年
//year = c.get(Calendar.YEAR);
//月
//month = c.get(Calendar.MONTH);
//天
//date = c.get(Calendar.DATE);
//System.out.println(year+"年"+(month+1)+"月"+date+"日");
//需求:5年后的十天前
c.add(Calendar.YEAR, 5);
c.add(Calendar.DATE, -10);
//获取年
year = c.get(Calendar.YEAR);
//获取月
month = c.get(Calendar.MONTH);
//月汇总的天
date = c.get(Calendar.DATE);
System.out.println(year+"年"+(month+1)+"月"+date+"日");
//public final void set(int year, intmonth, int date)
c.set(2018,5,20);
//获取年
year = c.get(Calendar.YEAR);
//获取月
month = c.get(Calendar.MONTH);
//月汇总的天
date = c.get(Calendar.DATE);
System.out.println(year+"年"+(month+1)+"月"+date+"日");
}
}
3. 键盘录入一个年份,获取任意一年的二月有多少天
分析:
1)创建键盘录入对象,录入某一个年份
2)获取日历类对象,getInstance()
3)设置一个日历字段,年,月,日
日历类对象.set(year,2,1):这里其实表示3月1
4)将时间往前推一天
日历类对象.add(Calendar.DATE,-1);
5)获取DATE月份中的天,输出即可
importjava.util.Calendar;
importjava.util.Scanner;
publicclass CalendarTest {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//录入并接收数据
System.out.println("请您输入一个年份:");
int year = sc.nextInt();
//创建日历类对象
Calendar c = Calendar.getInstance();
//设置日历的字段,年,月,日
c.set(year, 2, 1) ;//其实月份:(month+1):3月1
//将时间往前推算一天
c.add(Calendar.DATE, -1);
System.out.println("任意一年的二月有:"+c.get(Calendar.DATE));
}
}
七、Date类
1．Date类:日期类:
表示特定的瞬间，精确到毫秒。
常用的构造方式:
publicDate():表示分配的一个Date对象:无参: 通过无参构造获取当前系统的具体的时间
publicDate(long date):指定一个时间毫秒值 和它1970-1-1 00:00:00有时间差
importjava.util.Date;
publicclass DateDemo {
public static void main(String[] args){
//创建日期对象
Date d = new Date();
//输出日期对象
System.out.println("d:"+d);//SatNov 04 15:05:43 CST 2017 :获取当前系统的年月日以及时分秒星期
//设置一个时间long
long time = 1000/60/60;
Date d2 = new Date(time);
System.out.println("d2:"+d2);
}
}
2. Date中的两个成员方法
public long getTime():获取当前时间毫秒值
如果知道Date对象,可以通过getTime()获取时间毫秒值
public void setTime(long time)
importjava.util.Date;
publicclass DateDemo2
public static void main(String[] args) {
//创建一个日期对象
Date d = new Date();
System.out.println(d);
//public long getTime():获取当前时间毫秒值
long time = d.getTime();
//System.out.println(time);
//System.out.println(System.currentTimeMillis());
//通过System可以获取当前时间的毫秒数
//public void setTime(long time)
d.setTime(1000);
System.out.println(d);
}
}
3.将Date对象--->String类型的日期的"文本格式":格式化
public final String format(Date date)
String类型日期的"文本格式"---->Date日期对象:解析
public Date parse(String source) 该方法本身会抛出一个异常:ParseException(解析异常:编译时期异常)
要进行转换:必须使用中间桥梁:DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
日期/时间格式化子类（如SimpleDateFormat）允许进行格式化（也就是日期Date -> 文本String）、解析（文本String-> 日期Date）和标准化
但是,DateFormat是抽象类,不能直接实例化,使用的是它更具体的子类进行实例化:
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类
常用的构造方法:
Date---格式化--->String文本格式
public SimpleDateFormat(Stringpattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat
日期和时间模式
y 年 比如:2017---->yyyy
M 年中的月份:2------>MM
d 月份中的天数 :----->dd
H 小时 HH
m 小时中的分钟数 mm
s 分钟中的秒数 ss
importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Date;
publicclass DateFormatDemo {
public static void main(String[] args)throws ParseException {
//Date日期对象--->格式化---->String:日期文本格式
//创建日期对象
Date d = new Date() ;
//System.out.println(d);
//创建SimpleDateFormat类对象,用该对象格式化Date对象
SimpleDateFormat sdf = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
//格式化
//public final String format(Date date)
StringdateStr = sdf.format(d);
System.out.println("dateStr:"+dateStr);
System.out.println("-----------------------");
//String日期"文本格式"----->解析----->Date对象
/**
*注意事项:
*一定要保证SimpleDateFormat中的String Pattern这个模式和当前给的字符串的文本格式的模式必须一致
*/
String s = "2017-12-30";
//创建SimpleDateFormat类的对象,用该对象解析String的日期的"文本格式"
//SimpleDateFormat sdf2 = newSimpleDateFormat("yyyy年MM月dd日");
SimpleDateFormat sdf2 = newSimpleDateFormat("yyyy-MM-dd");
//ava.text.ParseException: Unparseabledate: "2017-12-30"
//开始解析
//public Date parse(String source)
Date d2 = sdf2.parse(s);
System.out.println("d2:"+d2);
}
}
4.将Date和String相互转换的日期工具类
importjava.text.ParseException;
importjava.text.SimpleDateFormat;
importjava.util.Date;
publicclass DateUtil {
//将无参构造私有化,为了不让外界创建对象
private DateUtil(){
}
/**
* 该方法是将Date日期对象格式化成一个String日期"文本格式"
*@param d
* 需要被转换的日期对象
*@param format
* 需要转换的时候提供的一种模式
*@return
* 最终返回的就是日期的文本格式
*/
public static String dateToString(Dated,String format){
//创建SimpleDateFormat对象
/*SimpleDateFormat sdf = new SimpleDateFormat(format);
//格式化
String str = sdf.format(d);
return str;*/
return new SimpleDateFormat(format).format(d);
}
/**
* 该方法是将String的日期"文本格式"解析成一个Date日期对象
*@param s
* 表示需要被解析的日期文本格式
*@param format
* 表示解析日期文本格式是需要使用的一种模式
*@return
* 返回的就是日期Date对象
*@throws ParseException
* 抛出解析异常
*/
public static Date stringToDate(Strings,String format) throws ParseException{
//创建SimpleDateFormat对象
/*SimpleDateFormat sdf = newSimpleDateFormat(format);
Date date = sdf.parse(s);
return date;*/
return new SimpleDateFormat(format).parse(s);
}
}
5.日期和String相互转换的一个测试类
importjava.text.ParseException;
importjava.util.Date;
publicclass DateUtilDemo {
public static void main(String[] args)throws ParseException {
//Date--->String
//创建一个Date对象
Date d = new Date();
//调用功能
String str = DateUtil.dateToString(d,"yyyy-MM-dd HH:mm:ss");
System.out.println("str:"+str);
String str2 = DateUtil.dateToString(d,"yyyy-MM-dd");
System.out.println("str2:"+str2);
String str3 = DateUtil.dateToString(d,"HH:mm:ss");
System.out.println("str3:"+str3);
//String---->Date
//模式要和字符串文本格式一致
String s = "2018-6-2516:26:21";
//调用功能
Date date = DateUtil.stringToDate(s,"yyyy-MM-dd HH:mm:ss");
System.out.println("date"+date);
}
}
6．键盘录入你的出生年月日,计算你来到这个世界有多少天了?
分析:
1)键盘键盘录入出生年月日,录入这一个String类型的数据
2)创建SimpleDateFormat对象指定一种模式
3)将当前String日期文本格式转换成date对象
4)通过Date对象获取getTime():获取时间毫秒值
5)得到当前系统时间的毫秒值(System.currentTimeMillis)
6):5)-4)=long 类型的时间
7)换算成多少天
8)输出
importjava.text.ParseException;
importjava.util.Date;
importjava.util.Scanner;
publicclass MyYearOldTest {
public static void main(String[] args)throws ParseException {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//录入并接收数据
System.out.println("请输入你的出生年月日: ");
String line = sc.nextLine();
//使用刚才DateUtil工具类
Date d = DateUtil.stringToDate(line,"yyyy-MM-dd");
//获取当前出生年日所在的时间毫秒值
long oldTime = d.getTime();
//获取当前系统时间的毫秒值
long nowTime = System.currentTimeMillis();
long time = nowTime - oldTime;
//换算
long day = time/1000/60/60/24;
//输出
System.out.println("你来到这个世界有"+day+"天了");
}
}
Day13
一、正则表达式
1.正则表达式常用的语法:
A:字符
x 字符 x :任意的字符
\\ 反斜线字符 在代码中书写正则表达式:\------>用两个\\代表一个反斜线
\t 制表符 ('\u0009')
\n 新行（换行）符 ('\u000A') IO流中要写入换行符号:windows"\r\n"
\r 回车符 ('\u000D')
B:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A 到 Z，两头的字母包括在内（范围）:当前字母大小均可
C:预定义字符类
. 任何字符 邮箱里面:如果本身就是.,那么在写正在表达式的时候,\.将当前.转义
\d 数字：[0-9] \d在正则表达式应用的时候:[0-9]--->\\d
\w 单词字符：[a-zA-Z_0-9]:简单一些字符串,单词字符(规则:数字或者字母)
javascript:[a-zA-Z0-9]
D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界 :
hello;world:haha:xixi
E:Greedy数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
应用：
1.String的分割功能:
public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
返回值类型是一个字符串数组类型
应用场景: QQ搜索好友 女 "18-24" String ages = "18-24" ;
importjava.util.Scanner;
publicclass RegexDemo {
public static void main(String[] args) {
//定义一个字符串
String ages = "18-24" ;
//定义正则规则
String regex = "-" ;
//public String[] split(String regex)
String[] strArray = ages.split(regex) ;
//如何得到当前字符数组中的元素(转换int类型的数据)
int startAge =Integer.parseInt(strArray[0]) ;
int endAge =Integer.parseInt(strArray[1]) ;
//键盘录入一个年龄,属于int类型的数据
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//录入并接收数据
System.out.println("请您输入一个年龄:");
int age = sc.nextInt() ;
//判断是否符我们要找的一类人
if(age>=startAge &&age<=endAge){
System.out.println("这就是我想要的...");
}else{
System.out.println("不是我们要找的...");
}
}
}
2. 分割功能的应用
publicclass RegexDemo2 {
public static void main(String[] args) {
//定义个字符串
String str1 = "aa,bb,cc";
//使用分割功能
String[] strArray1 =str1.split(",");
//遍历字符串数组
for(int x = 0 ; x < strArray1.length;x ++){
System.out.println(strArray1[x]);
}
System.out.println("------------------");
//字符串:
String str2 = "aa bb cc";
//使用切割功能:
String[] strArray2 = str2.split("+");
for(int x = 0 ; x <strArray2.length ;x++){
System.out.println(strArray2[x]);
}
System.out.println("--------------------");
String str3 = "aa.bb.cc" ;
//分割功能
String[] strArray3 =str3.split("\\.");
for(int x =0 ; x<strArray3.length ; x++){
System.out.println(strArray3[x]);
}
//使用分割功能
String[] strArray4 =str4.split("\\\\");
for(int x = 0 ; x <strArray4.length ;x ++){
System.out.println(strArray4[x]);
}
}
}
3.String类中的替换功能:和正则表达式有关系
public StringreplaceAll(String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
publicclass RegexDemo3 {
public static void main(String[] args) {
//定义一个字符串:
String str = "helloword123JavaSE45678Javaweb";
//需求:让当前这个字符串中的数字不显示出来
//定义当前大串中数字定义正则规则
//String regex = "[0-9]+";
String regex = "\\d+";
String s = "*";
//public String replaceAll(Stringregex,String replacement)
String result = str.replaceAll(regex, s);
System.out.println("result:"+result);
}
}
4. 校验邮箱
QQ邮箱: 919081924@qq.com
fengqingyang@163.com
xxxxx@126.com
zhangsan@westos.com
lisi@sina.com
分析: 1)键盘录入邮箱
2)定义正则规则
3)使用String中的特有功能校验
4)输出即可
import java.util.Scanner;
public class RegexTest {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//录入并接收
System.out.println("请您输入一个邮箱:");
String email = sc.nextLine();
//定义正则规则:本身就是.-->\.--->\\.
//String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z]{2,3})+";
String regex ="\\w+@\\w{2,6}(\\.[a-zA-Z]{2,3})+";
//校验
boolean flag = email.matches(regex);
System.out.println("flag:"+flag);
}
}
5. 使用正则表达式校验手机号码:
规则:
手机号码:
13689257284
13688886666
13892866555
18992844422
13257222222
...
1)创建键盘录入对象,录入手机号码
2)定义正则规则:
3)String类的特有功能
public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
4)输出
importjava.util.Scanner;
publicclass RegexDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//录入并接收
System.out.println("请您输入一个手机号码:");
String phone = sc.nextLine();
//定义正则规则
String regex = "1[38][0-9]{9}";
//匹配当前正则表达式是否和录入的手机号符合
boolean flag = phone.matches(regex);
System.out.println("flag:"+flag);
}
}
6. 如下一个字符串:"91 27 46 38 50"
请写代码实现最终输出结果是："27 38 46 50 91"
分析:
1)定义这个字符串
2)使用分割功能分割成一个字符串数组
3)如何得到一个int类型数组:动态初始化定义int数组 int[] arr = new int[字符串数数组.length] ;
4)遍历int数组,获取每一个元素:arr[x] = Integer.parseInt(字符串数组对象[x])
5)排序:Arrays数组工具类型快速排序:sort(arr)
6)再去遍历int类型数组获取每一个元素,用字符串缓冲区来进行拼接
7)输出字符串
importjava.util.Arrays;
publicclass RegexTest {
public static void main(String[] args) {
//定义一个字符串
String str = "91 27 46 38 50";
//使用分割功能
String[] strArray = str.split("") ;
//定义一个int类型的数组,动态初始化
int[] arr = new int[strArray.length] ;
//遍历int类型的数组
for(int x = 0 ; x < arr.length ; x++){
arr[x] =Integer.parseInt(strArray[x]) ;
}
//使用Arrays数组工具类型进行操作
Arrays.sort(arr);
//创建StringBuilder缓冲区对象
StringBuilder sb = new StringBuilder();
//再去遍历int类型的数组,目的使用为了拼接
for(int x = 0 ; x < arr.length ; x++){
//使用追加功能
sb.append(arr[x]).append("");
}
//要将字符串缓冲转换成String类型,并且去除两端空格
String result = sb.toString().trim();
System.out.println("result:"+result);
}
}
7. 关于模式和匹配器的使用:获取功能
模式和匹配器基本使用顺序
importjava.util.regex.Matcher;
importjava.util.regex.Pattern;
publicclass RegexDemo4 {
public static void main(String[] args) {
//public static Pattern compile(Stringregex)将给定的正则表达式编译成一个模式对象
//1)获取模式对象(通过正则规则)
Pattern p =Pattern.compile("a*b");
//2)通过模式获取匹配器对象,(将一个字符串类型的数据)
Matcher m =p.matcher("aaaaaab");
//3)调用Match(匹配器类)中的:publicboolean matches():判断当前用户录入的字符串是否和当前的正则规则匹配
boolean flag = m.matches();
System.out.println("flag:"+flag);
System.out.println("----------------------------");
//上述写法非常麻烦,要获取模式对象Pattern还要获取匹配器对象:Matcher,然后通过matches()方法返回一个结果
//以后可以使用下面这种格式
//定义一个正则规则
String regex = "a*b";
//指定某一个字符串
String str = "aaaaaaab";
//使用String类的功能
//使用当前给定的字符串调用public boolean matchers(String regex)
boolean flag2 = str.matches(regex);
System.out.println("flag2:"+flag2);
}
}
7.需求:校验一个QQ号码
定义一个规则: 1)由5到10为组成的数字
2)不能以0开头
分析:
1)键盘录入一个QQ号码,使用字符串接收
2)定义一个校验QQ的功能
3)在main()中调用返回boolean类型
方法一：
importjava.util.Scanner;
publicclass RegexDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//录入并接收数据
System.out.println("请您输入一个QQ号码:");
String QQ = sc.nextLine();
//写一个校验QQ的功能
boolean flag = checkQQ(QQ);
System.out.println("flag:"+flag);
}
/**
* 两个明确:
* 明确返回值类型:boolean类型
* 参数类型:String 输入的qq号码
*/
public static boolean checkQQ(String qq){
//假设定义个标记
boolean flag = true;
//需要判断:qq:长度5-10
if(qq.length()>=5 &&qq.length()<=10){
//符合这个规则
//符合第一个规则还要符合不能以0开头
if(!qq.startsWith("0")){
//符合这个规则
//这些QQ号码必须还数字的
//可以先将qq,转换成字符数字
char[] chs = qq.toCharArray();
//遍历字符数组,获取每一个字符
for(int x = 0 ; x < chs.length; x ++){
char ch = chs[x];
//获取到每一个字符,判断该字符是否是数字
if(!Character.isDigit(ch)){
flag = false;
break;
}
}
}else{
flag = false;
}
}else{
flag = false;
}
return flag;
}
}
方法二:
importjava.util.Scanner;
publicclass RegexDemo2 {
public static void main(String[] args) {
//创建键盘了录入对象
Scanner sc = new Scanner(System.in);
//录入并接收数据
System.out.println("请您输入QQ号码: ");
String QQ = sc.nextLine();
boolean flag = checkQQ(QQ);
System.out.println("flag:"+flag);
}
public static boolean checkQQ(String qq){
/*//定义正则规则
String regex ="[1-9][0-9]{4,9}";
//public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
boolean flag = qq.matches(regex);
return flag;*/
//直接返回
return qq.matches("[1-9]\\d{4,9}");
}
}
二、集合
1. 集合的由来:
我们学习java的语言,是一种面向对象语言,面向对象语言对事物的描述是通过对象体现出来的,那么存储很多个学生,就需要使用容器变量进行存储
目前:学习过哪些容器变量呢?
数组,StringBuffer/StringBuilder,对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变);对于StringBuffer来说始终在内存中返回的是字符串类型,也不满足元素类型变化的要求;所以,Java就提供了一个技术:集合.
面试题:
集合和数组的区别?
1)长度的区别:
数组:长度是固定的;
集合:长度是可变的
2)存储数据类型的区别:
数组:可以存储引用类型,可以存储基本数据类型
集合:只能存储引用类型
3)存储元素的区别
数组:在同一个数组中,只能存储同一种数据类型的元素;举例 数组:杯子:只能装水
集合:可以 存储多种数据类型的元素; 举例:集合:杯子:装水,其他饮料...
集合是可以存储多种类型的元素,但是,需求如果变化,针对集合来说,Java提供了很多集合类,每一种集合类的数据结构不一样,所以,将他们之间的共性内容抽取出来就行了
例：
数组：
对象数组:可以存储对象的数组
需求:有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来! 分析:A:定义一个学生类:
提供两个成员 变量
String name,int age
提供无参/有参的构造方法
提供set/get()方法
B:定义一个学生数组(对象数组)
C:创建5个学生对象
D:赋值,将5个学生对象放到学生数组中
E:遍历数组
F:输出
publicclass ObjectArrayDemo {
public static void main(String[] args) {
//学生类创建完毕
//定义一个学生数组:定义数组的格式:数据类型[] 数组名称 = new 数据类型[数组长度] ;
//定义一个学生数组
Student[] students = new Student[5] ;
//创建5个学生对象
Student s1 = new Student("高圆圆", 27) ;
Student s2 = new Student("黄晓明", 28) ;
Student s3 = new Student("邓超",30) ;
Student s4 = new Student("孙俪",28) ;
Student s5 = new Student("王昭君",25) ;
//赋值
students[0] = s1 ;
students[1] = s2 ;
students[2] = s3 ;
students[3] = s4 ;
students[4] = s5 ;
//遍历学生数组
for(int x = 0 ; x <students.length ;x ++){
//System.out.println(students[x]);
//通过底层原码重写toString()得到的每个对象的成员变量的信息
Student s = students[x] ;
System.out.println(s.getName()+"----"+s.getAge());
}
}
}
publicclass Student {
//两个成员变量
private String name ;
private int age ;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
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 String toString() {
return "Student [name=" + name+ ", age=" + age + "]";
}
}
集合：
需求:有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来!
使用集合的转换功能去遍历学生信息
1)创建集合对象
2)创建5个学生对象
3)使用集合添加5个学生对象
4)将集合转换成数组:Object[] toArray() ;
5)遍历数组
public class CollectionTest {
public static voidmain(String[] args) {
//创建集合对象
Collection c = newArrayList() ;
//创建5个学生对象
Student s1 = newStudent("貂蝉",25) ;
Student s2 = newStudent("王昭君",22) ;
Student s3 = newStudent("西施",28) ;
Student s4 = newStudent("杨贵妃",29) ;
Student s5 = newStudent("高圆圆",38) ;
//给集合中添加元素
c.add(s1) ;//Objectobj = new Student("..") ;
c.add(s2) ;
c.add(s3) ;
c.add(s4) ;
c.add(s5) ;
//将集合转换成数组
Object[] objs =c.toArray() ;
for(int x = 0 ; x< objs.length ; x ++){
//System.out.println(objs[x]);
//使用get()获取学生姓名和年龄
//Student类型接收
Student s =(Student) objs[x] ;
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
public class Student {
private String name ;
private int age ;
public Student() {
super();
}
public Student(Stringname, int age) {
super();
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public voidsetName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(intage) {
this.age = age;
}
@Override
public StringtoString() {
return"Student [name=" + name + ", age=" + age + "]";
}
}
数据结构:存储数据的方式
Collection: 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现
Collection的一些功能
添加功能:
booleanadd(Object e):给集合中添加指定的元素
booleanaddAll(Collection c):添加一个集合中的所有元素
删除功能:
voidclear():删除一个集合中的所有元素,暴力删除,(不建议使用)
booleanremove(Object o):删除一个集合中的指定元素
booleanremoveAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?
判断功能:
booleancontains(Object o):判断一个集合中是否包含指定的单个元素
booleancontainsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有.
booleanisEmpty():判断集合是否为空,如果为空,则返回true
交集功能:
booleanretainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
获取功能;
int size():获取集合中的元素数
Iterator<E>iterator():迭代器
转换功能:
Object[]toArray():将集合转换成数组
面试题:
数组中有没有length(),String类中有没有length(),集合中有没有length()?
数组:length属性
String:length()
集合中:size()
importjava.util.ArrayList;
importjava.util.Collection;
publicclass CollectionDemo {
public static void main(String[] args) {
//创建一个Collection集合对象
//Collection c = new Collection() ;//JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现
Collection c = new ArrayList() ;
//System.out.println(c);//[] 底层重写了toString()
//添加功能:
//boolean add(Object e):给集合中添加指定的元素
//boolean flag = c.add("hello") ;
/**
*通过查看集合的add()方法,只要给集合中添加元素,永远返回true
* public boolean add(E e) {
* //省略代码
returntrue;
}
*/
c.add("hello") ;
c.add("world") ;
c.add("Java") ;
//void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
//c.clear() ;
//boolean remove(Object o):删除一个集合中的指定元素
//System.out.println("remove:"+c.remove("hello"));
//System.out.println("remove:"+c.remove("javaweb"));
//boolean contains(Object o):判断一个集合中是否包含指定的单个元素
System.out.println("contains:"+c.contains("world"));
//System.out.println("contains:"+c.contains("android"));
//boolean isEmpty():判断集合是否为空,如果为空,则返回true
//System.out.println("isEmpty:"+c.isEmpty());
//int size():获取集合中的元素数
System.out.println("size:"+c.size());
System.out.println("c:"+c);
}
}
2. 集合的高级功能:
booleanaddAll(Collection c):添加一个集合中的所有元素
booleanremoveAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?
booleancontainsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有
boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
importjava.util.ArrayList;
importjava.util.Collection;
publicclass CollectionDemo2 {
public static void main(String[] args) {
//创建两个Collection集合对象
Collection c1 = new ArrayList() ;
Collection c2 = new ArrayList() ;
//分别给c1,c2集合添加元素
c1.add("abc1") ;
c1.add("abc2") ;
c1.add("abc3") ;
c1.add("abc4") ;
/*c2.add("abc1") ;
c2.add("abc2") ;
c2.add("abc3") ;*/
c2.add("abc4") ;
//c2.add("abc5") ;
//c2.add("abc6") ;
//c2.add("abc7") ;
//boolean addAll(Collection c):添加一个集合中的所有元素
//System.out.println("addAll:"+c1.addAll(c2));
//boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?
//删除一个算是删除
//System.out.println("removeAll:"+c1.removeAll(c2));
//boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有
//System.out.println("containsAll:"+c1.containsAll(c2));//包含所有算是包含
//boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
/**
*面试题:
*A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false
*/
System.out.println("retianAll:"+c1.retainAll(c2));
//输出每个集合中的元素
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
}
}
3. Object[]toArray():将集合转换成数组
需求:给集合中添加String类型的元素,遍历集合
importjava.util.ArrayList;
importjava.util.Collection;
publicclass CollectionDemo3 {
public static void main(String[] args) {
//创建Collection集合对象
Collection c = new ArrayList() ;
//给集合中添加元素
c.add("高圆圆") ;//c.add(Object obj)=====>Objectobj = new String("高圆圆") ;//向上转型了
c.add("邓超") ;
c.add("WE") ;
c.add("RNG") ;
//集合中有元素了,将集合转换数组
Object[] objs = c.toArray() ;
//遍历对象数组
for(int x = 0 ; x < objs.length ; x++){
//System.out.println(objs[x]);
//需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度
//System.out.println(objs[x]+"---"+objs[x].length());
//要获取字符串长度:需要使用length(),该方法属于String类的特有功能
String s = (String) objs[x] ;//向下转型
System.out.println(s+"----"+s.length());
}
}
}
4. 集合的专有遍历方式:使用集合自己本身迭代功能遍历集合中的元素
Iteratoriterator():迭代器
Iterator:迭代器:接口
成员方法:Objectnext()返回迭代的下一个元素:获取功能
booleanhasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能
需求:使用集合存储字符串类型的元素并遍历
publicclass CollectionDemo {
public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();//ArrayList是List集合的子实现类(存储和取出一致的)
//给集合中添加元素
c.add("hello") ;
c.add("world") ;
c.add("java") ;
c.add("java") ;
c.add("java") ;
c.add("java") ;
//获取迭代器对象
//Iterator iterator():迭代器
Iterator it = c.iterator() ;//底层使用ArrayList中的匿名内部类的形式:接口多态的形式
//获取元素:Object next() ;
/*Object obj = it.next() ;
System.out.println(obj);*/
//System.out.println(it.next());
//System.out.println(it.next());
//System.out.println(it.next());
//java.util.NoSuchElementException:没有这样的元素异常!
//System.out.println(it.next());
//由于当前集合中的元素获取完了,没有元素,而还要去调用next()方法,那么就出现问题,
//假设,给当前加上一个判断就可以防止出现异常!
//判断
/* if(it.hasNext()){
//有,就获取需要被遍历的元素
System.out.println(it.next());
}
if(it.hasNext()){
//有,获取
System.out.println(it.next());
}
if(it.hasNext()){
System.out.println(it.next());
}
if(it.hasNext()){
System.out.println(it.next());
}*/
//上述代码重复度高,由于集合中的元素不固定的,所有使用while循环去改进
while(it.hasNext()){
//System.out.println(it.next());//获取字符串的内容
//获取字符串的同时,还要获取字符串长度
//Object obj = it.next() ;
//向下转型
String s = (String)it.next() ;
System.out.println(s+"----"+s.length());
}
}
}
5. 使用存储自定义对象并遍历
1)toArray():将集合转换成数组
2)集合专有遍历方式:迭代器遍历
注意:存储自定义对象使用迭代器遍历,it.next()不要使用多次,否则会出现异常!
使用迭代器遍历,使用的是while循环,可以是for循环吗?可以,但是还是while循环
importjava.util.ArrayList;
importjava.util.Collection;
importjava.util.Iterator;
publicclass CollectionTest {
public static void main(String[] args) {
//创建一个学生类
//创建集合对象
Collection c = new ArrayList() ;
//创建3个学生对象
Student s1 = new Student("张三", 26) ;
Student s2 = new Student("李四", 22) ;
Student s3 = new Student("往往与", 28) ;
//给集合中添加元素
c.add(s1) ;
c.add(s2) ;
c.add(s3) ;
//获取迭代器对象
Iterator it = c.iterator() ;
//遍历
while(it.hasNext()){
Student s = (Student)it.next() ;
System.out.println(s.getName()+"---"+s.getAge());
//java.util.NoSuchElementException
System.out.println(((Student)it.next()).getName()+"----"+((Student)it.next()).getAge());
}
System.out.println("----------------------------");
for(Iterator it2 =c.iterator();it2.hasNext();){
Student s = (Student) it2.next() ;
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
publicclass Student {
private String name ;
private int age ;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
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 String toString() {
return "Student [name=" + name+ ", age=" + age + "]";
}
}
6. 用List集合存储字符串类型的元素,并遍历:迭代器遍历
importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;
publicclass ListDemo {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//获取迭代器
Iterator it = list.iterator() ;
while(it.hasNext()){
String s = (String)it.next() ;
System.out.println(s);
}
}
}
7.List集合是一个有序的集合(存储元素和取出元素是一致的!)
该集合中的元素是可以重复的
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo2 {
publicstatic void main(String[] args) {
//创建List集合对象
Listlist = new ArrayList() ;
//给集合中添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("java");
list.add("javaweb");
list.add("world");
//获取迭代器
Iteratorit = list.iterator() ;
while(it.hasNext()){
Strings = (String)it.next() ;
System.out.println(s);
}
}
}
8. List集合的特有功能:
添加功能:
void add(int index, Object element)在列表的指定位置插入指定元素
删除功能:
Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
获取功能:
ListIterator listIterator():列表迭代器:List集合的专有遍历方式
Object get(int index)返回列表中指定位置的元素。
替换
set(int index,Object element)用指定元素替换列表中指定位置的元素
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
publicstatic void main(String[] args) {
//创建List集合对象
Listlist = new ArrayList() ;
//添加一些元素
list.add("hello");
list.add("world");
list.add("java");
//voidadd(int index, Object element)在列表的指定位置插入指定元素,在指定位置前面插入一个新的元素
//list.add(1, "javaweb") ;
//Objectremove(int index)移除列表中指定位置的元素,返回被删除的元素
//IndexOutOfBoundsException:角标越界了
//System.out.println("remove:"+list.remove(3));
//System.out.println("remove:"+list.remove(2));
//set(int index,Object element)用指定元素替换列表中指定位置的元素
//System.out.println("set:"+list.set(1,"JavaEE")) ;
System.out.println("get:"+list.get(1));
//System.out.println("get:"+list.get(11));
System.out.println("list"+list);
}
}
9.List集合的遍历方式
1)toArray()
2)Collection集合中的Iterator iterator();
importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;
publicclass ListDemo2 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//添加元素
list.add("hello") ;
list.add("java") ;
list.add("hello") ;
list.add("javaweb") ;
list.add("hello") ;
list.add("python") ;
//获取集合中的元素
/*System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println(list.get(3));
System.out.println(list.get(4));
System.out.println(list.get(5));*/
//使用普通for的方法去遍历list集合,使用size()和get()相结合
for(int x = 0 ; x < list.size(); x ++){
//Object object = list.get(x) ;
//需求:获取字符串内容同时,获取字符串长度
String s = (String)list.get(x) ;
System.out.println(s+"----"+s.length());
}
System.out.println("-------------------------");
//获取迭代器对象
Iterator it = list.iterator() ;
while(it.hasNext()){
String s = (String) it.next() ;
System.out.println(s+"----"+s.length());
}
}
}
10.List集合的列表迭代器
ListIteratorlistIterator()
列表迭代器接口中有以下几个方法:
booleanhasNext():判断是否有下一个可以迭代的元素(正向遍历)
Objectnext():如果有可以遍历的元素,就获取这个元素
booleanhasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
Object previous():如果有上一个可以迭代的元素,就获取上一个元素
注意:
要使用逆向遍历,前提必须有正向遍历存在,直接使用逆向遍历,没有意义!
importjava.util.ArrayList;
importjava.util.List;
importjava.util.ListIterator;
publicclass ListDemo3 {
public static void main(String[] args) {
//创建集合对象
List list = new ArrayList() ;
//给集合中添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//获取列表迭代器
ListIterator it = list.listIterator() ;
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s);
}
System.out.println("-----------------------");
//boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
//Object previous():如果有上一个可以迭代的元素,就获取上一个元素
while(it.hasPrevious()){
String s = (String)it.previous() ;
System.out.println(s);
}
}
}
11．问题?
有一个集合，如下，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
并发(同一个时间点),并行(同一个时间段)
java.util.ConcurrentModificationException:并发修改异常:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
原因:当前我们用迭代器去遍历元素,使用集合添加的元素,对于迭代器不知道集合添加了这个元素,所以会发生这个异常
描述:使用迭代器去遍历集合,是不能直接集合添加元素!
解决方案:
1)使用迭代器遍历集合,使用迭代器添加元素
2)使用集合遍历,使用集合添加元素
importjava.util.ArrayList;
importjava.util.Iterator;
importjava.util.List;
importjava.util.ListIterator;
publicclass ListTest {
public static void main(String[] args) {
//创建List集合对象
List list = new ArrayList() ;
//给集合中添加元素
list.add("hello") ;
list.add("world") ;
list.add("java") ;
//获取迭代器
//Iterator it = list.iterator() ;
//遍历
//while(it.hasNext()){
//String s = (String)it.next() ;
//判断
//if("world".equals(s)){
//添加一个元素
//list.add("javaee") ;
//}
//}
//方案1:1)使用迭代器遍历集合,使用迭代器添加元素
//Iterator it = list.iterator() ; 该迭代器中没有添加功能,List集合中的专有遍历方式:列表迭代器有添加功能:add(Object obj)
//将指定的元素插入到列表中(指定元素后面插入)
//ListIterator it = list.listIterator();
//while(it.hasNext()){
//String s = (String) it.next() ;
//判断
//if("world".equals(s)){
//使用迭代器添加
//it.add("javaee") ;
//}
//}
//方案2:使用集合遍历(普通for循环size()和get()相结合),使用集合添加元素
for(int x = 0 ; x <list.size() ; x++){
String s = (String) list.get(x) ;
//判断
if("world".equals(s)){
//集合添加
list.add("javaee") ;//在末尾添加元素
}
}
//输出集合
System.out.println("list:"+list);
}
}
扫一扫
1407
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
