2019-05-24 Java学习日记 day14
冒泡排序
其一行的上浮，沉的下降
两个相邻位置比较，如果前面的元素比后面的元素大就换位置
public class demo1_Array { public static void main(String[] args) { int [] arr={32,50,89,20,78}; bubbleSort(arr); print(arr); } public static void bubbleSort(int [] arr){ for (int i = 0; i < arr.length-1; i++) { //外循环只需要比较arr.length-1次就可以了 for (int j = 0; j < arr.length-1-i; j++) { //-1为了防止索引越界 if(arr[j] > arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } public static void print(int [] arr){ for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } } }
选择排序：用一个索引位置上的元素，依次与其他索引位置上的元素比较小在前面大的在后面
public class demo2_Array { public static void main(String[] args) { int [] arr={10,50,20,30,80}; selectarray(arr); print(arr); } public static void selectarray(int [] arr){ for (int i = 0; i < arr.length-1; i++) {//只需要比较arr.length-1 for (int j = i+1; j < arr.length; j++) { if (arr[i] < arr[j]) { // int temp=arr[i]; // arr[i]=arr[j]; // arr[j]=temp; st(arr, i, j); //如果只针对本类提供使用，就不需要封装成公共的 } } } } public static void print(int [] arr){ for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+ " "); } } public static void st(int [] arr,int i,int j){ int temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } }
二分查找
如果数组无序，就不能使用二分查找
public class demo3_Array { public static void main(String[] args) { int [] arr ={11,22,33,44,55,66,77}; System.out.println(print(arr, 44)); System.out.println(print(arr, 66)); System.out.println(print(arr, 88)); } public static int print(int [] arr,int value){ int min=0; int max=arr.length-1; int mid=(max+min)/2; while (arr[mid] !=value) { //当中间值不等于要找得知，就开始循环查找 if (arr[min]<value) { //当中间值小于了要找的值 min=mid+1; //最小的索引改变 }else if (arr[mid]>value) { //当中间值大于了要找的值 max=mid-1; //最大的索引改变 } mid=(max+min)/2; //无论最大还是最小改变，中间索引都会随之改变 if (min>max) { //如果最小索引大于了最大索引，就没有查找的可能性 return -1; } else { } } return mid; } }
Arrays
针对数组进行操作的工具类
提供了排序，查找等功能
成员方法：
public static String toString(int[] a)
public static void sort(int [] a)
public static int binarySearch(int [] a,int key)
public class demo4_Arrays { public static void main(String[] args) { int [] arr ={11,55,66,44,22,88}; System.out.println(Arrays.toString(arr)); //数组转字符串 Arrays.sort(arr); System.out.println(Arrays.toString(arr)); //排序 int [] arr2={11,22,33,44,55,66}; System.out.println(Arrays.binarySearch(arr2,11)); System.out.println(Arrays.binarySearch(arr2,88)); //负的插入点-1 6-（-1）=-7 System.out.println(Arrays.binarySearch(arr2,34)); } }
基本类型包装
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能功能能方法操作该数据
常用操作：
常用的操作之一：用于基本数据类型与字符串之间的转换
基本类型的包装类的对应：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer
Integer类在对象包装了一个基本类型 int 的值
该类提供了多个方法，能在int 类型和String类型之间互相转换
还提供了处理 int 类型是非常有用的其他一些常量和方法
构造方法：
public Integer (int value)
public Integer(String s)
public class demo2_Integer { public static void main(String[] args) { System.out.println(Integer.MAX_VALUE); System.out.println(Integer.MIN_VALUE); Integer i1=new Integer("5227665"); System.out.println(i1); } }
Integer 和iint
public class demo3_Integer { public static void main(String[] args) { //int 转换成 String int i=100; String s1=i+""; //推荐用 String s2=String.valueOf(i);//推荐用 Integer i1=new Integer(i); String s3=i1.toString(); String s4=Integer.toString(i); System.out.println(s4); //String 转换成 int String s="200"; Integer i2=new Integer(s); int i3=i2.intValue(); int i4=Integer.parseInt(s); System.out.println(i4);//String 转换 int } }
JDK5新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
public class demo4_JDK5 { public static void main(String args[]){ Integer i1 = 100; int z = i1 + 200; System.out.println(z); //自动拆箱 Integer i2 =null; //调用null会出现异常 int a =i2 + 100; System.out.println(a); } }
正则表达式
是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用
public class demo1_regex { public static void main(String[] args) { //System.out.println(checkQQ("1234567")); String regex="[1-9]\\d{4,14}"; System.out.println("553868".matches(regex)); } public static boolean checkQQ(String qq){ boolean flag =true; if(qq.length() >=5 && qq.length() <=15){ if(!qq.startsWith("0")){ //startsWith判斷是否0开头 char[] arr=qq.toCharArray();//将字符串转换成字符数组 for (int i = 0; i < arr.length; i++) { char ch=arr[i]; //记录每个字符 if (!(ch >='0' && ch <='9')) { flag =false; //不是数字 break; } } }else{ flag=false; //以0开头，不符合qq标准 } }else{ flag =false; //长度不符合 }return flag; } }
字符类：
[abc] a,b 或 c (简单类)
[^abc] 任何字符,除了 a,b,c(否定)
[a-zA-Z] a到 z 或 A 到 Z，两头的字母包括在内(范围)
[0-9] 0到9的字符都包括
.任何字符
\d 数字：[0-9]
\D 非数字：[^0-9]
\s 空白字符：[\t\n\xOB\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X,一次或多次
X{n} X，恰好n 次
X{n，} X，至少n 次
X{n，m} X，至少 n 次，但是不超过 m 次
正则表达式的分割功能
public class demo4_regex { public static void main(String[] args) { String s="我.热爱.学习"; //.代表任意字符 String [] arr=s.split("\\."); // \\转义 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }
public static void main(String[] args) { String s="91 27 36 48 50"; //将字符串切割成字符串数字 String [] arrs=s.split(" "); int [] arr=new int[arrs.length]; //将字符串转换成数字并将其存储在一个等长度打的int数字中 for (int i = 0; i < arr.length; i++) { arr[i] =Integer.parseInt(arrs[i]);//将数字字符串转换成数字 } Arrays.sort(arr); StringBuffer sb=new StringBuffer(); for (int i = 0; i < arrs.length; i++) { if(i==arr.length){ sb.append(arr[i]); }else{ sb.append(arr[i]+" "); } } System.out.println(sb); }
正则表达式替换功能
public String replaceAll(Dtrinf regex,String replacement)
public class demo6_ReplaceAll { public static void main(String[] args) { String s1="wo1ai2xuexi"; String regex="\\D"; String s2=s1.replaceAll(regex, ""); System.out.println(s2); } }
正则表达式分组功能
捕获组可以通过从做导游计算其开括号来编号。例如，在表达式( ( A ) ( B ( C ) ) )中，存在四个这样的组:
( ( A ) ( B ( C ) ) )
(A
(B(C))
(C)
组零始终代表整个表达式
public class demo7_regex { public static void main(String[] args) { //demo1(); //demo2(); String s1="高高兴兴..快.快.快乐快乐乐..乐...乐"; String s2=s1.replaceAll("\\.", ""); String s3=s2.replaceAll("(.)\\1+(.)", "$1"); System.out.println(s3); } public static void demo2() { String s1="我我..我..要....要......要学...学..编程...程...程"; String s2=s1.replaceAll("\\.", ""); String s3=s2.replaceAll("(.)\\1+", "$1"); //$1 代表第一组中的内容 System.out.println(s3); } public static void demo1() { String s1="sdqqfgkkkhjppppkl"; String regex= "(.)\\1+"; //+代表第一组出现一次到多次 String [] arr=s1.split(regex); for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }
Pattern和Matcher
模式和匹配器的典型调用顺序
Pattern p = Pattern.compile("a * b");
Matcher m = p.mather("aaaaab");
boolean b = m.matches()
正则表达式的获取功能
public class demo8_Pattern { public static void main(String[] args) { //demo1(); String s1="我的手机号是18607564024.曾静用过15919119193，还用过13543063543"; String regex="1[35689]\\d{9}"; //手机号码的正则表达式 Pattern p = Pattern.compile(regex); Matcher m = p.matcher(s1); // boolean b=m.find(); // String s2=m.group(); while (m.find()) { System.out.println(m.group()); } } public static void demo1() { Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); boolean b = m.matches(); System.out.println(b); } }
Math
Math概述Math类包含用于执行基本数学运算的犯法，如初等指数，对数，平方根和三角函数
成员方法
public static int abs(int a)
public static double ceil(doule a)
public static double floor(double a)
public static int max(int a,int b) min自学
public static double pow(double a,double,b)
public static double random()
public static int round(flaoat a) 参数为double的自学
public static double sqrt(double a)
public class demo1_Math { public static void main(String[] args) { System.out.println(Math.PI); System.out.println(Math.abs(-10)); //取绝对值 //ceil天花板,获取向上取整，但是结果是一个double System.out.println(Math.ceil(12.3)); //向下取整 System.out.println(Math.floor(12.3)); //获取两个值中的最大值 System.out.println(Math.max(10, 20)); //前面的数是底数，后面的数是指数 System.out.println(Math.pow(2, 3)); //2.0^3.0=8 //生成0.0到1.0之间的所以小数 System.out.println(Math.random()); //四舍五入 System.out.println(Math.round(12.5f)); //开平方 System.out.println(Math.sqrt(3)); } }
Random类的概述
Random类的概述此类用于产生随机数如果用相同的种子创建两个 Random 实例
则对每个实例进行相同的方法调用序列，他们将生成并返回相同的数字序列
构造方法
public Random()
public Random(long seed)
成员方法
public int nexInt()
public int nextInt(int n)
package tan.jung.otherclass; import java.util.Random; public class demo2_Random { public static void main(String[] args) { Random r1=new Random(); for (int i = 0; i < 5; i++) { System.out.println(r1.nextInt(100)); //生成0到n范围内的随机数，还包含0不包含n } Random r2=new Random(1000); int a=r2.nextInt(); int b=r2.nextInt(); System.out.println(a); System.out.println(b); } }
System类的概述
* System 类包含一些有用的类字段和方法。它不能被实例化。
* 成员方法
* public static void gc()
* public static void exit(int status)
* public static long currentTimeMillis()
* pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
public class demo3_System { public static void main(String[] args) { //demo1(); //demo2(); //demo3(); int [] arr={1,5,3,8}; int [] dest=new int[8]; for (int i = 0; i < dest.length; i++) { System.out.println(dest[i]); } System.arraycopy(arr, 0, dest, 0, arr.length); for (int i = 0; i < dest.length; i++) { System.out.println(dest[i]); } } public static void demo3() { long start=System.currentTimeMillis(); for (int i = 0; i < 1000; i++) { System.out.println("*"); } long end=System.currentTimeMillis();//获取当前的毫秒值 System.out.println(end-start); } public static void demo2() { System.exit(0); //退出java虚拟机 System.out.println("11111111"); } public static void demo1() { for (int i = 0; i < 10; i++) { new demo(); System.gc(); //运行垃圾收回器 } } } //在一个源文件中，是不允许定义两个public修饰类 class demo{ @Override public void finalize(){ System.out.println("垃圾被清扫了"); } }
BigInteger的概述
* 可以让超过Integer范围内的数据进行运算
构造方法:
* public BigInteger(String val)
成员方法:
* public BigInteger add(BigInteger val)
* public BigInteger subtract(BigInteger val)
* public BigInteger multiply(BigInteger val)
* public BigInteger divide(BigInteger val)
* public BigInteger[] divideAndRemainder(BigInteger val)
public class demo4_biginteger { public static void main(String[] args) { BigInteger bi1=new BigInteger("100"); BigInteger bi2=new BigInteger("2"); System.out.println(bi1.add(bi2));//+ System.out.println(bi1.subtract(bi2));//- System.out.println(bi1.multiply(bi2));//* System.out.println(bi1.divide(bi2)); //% BigInteger[] arr=bi1.divideAndRemainder(bi2); //取除数和余数 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]);//、、 } } }
BigDecimal的概述
* 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
* 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
* 不可变的、任意精度的有符号十进制数。
构造方法：
* public BigDecimal(String val)
成员方法：
* public BigDecimal add(BigDecimal augend)
* public BigDecimal subtract(BigDecimal subtrahend)
* public BigDecimal multiply(BigDecimal multiplicand)
* public BigDecimal divide(BigDecimal divisor)
package tan.jung.otherclass; import java.math.BigDecimal; import java.math.BigInteger; public class Demo5_BigDecimal { public static void main(String[] args) { // BigDecimal bd1=new BigDecimal(2.0); //不够精确 // BigDecimal bd2=new BigDecimal(1.1); // System.out.println(bd1.subtract(bd2)); // BigDecimal bd1 =new BigDecimal("2.0");//通过构造方法传入字符串的方式 // BigDecimal bd2 =new BigDecimal("1.1"); // System.out.println(bd1.subtract(bd2)); BigDecimal bd1 = BigDecimal.valueOf(2.0); BigDecimal bd2 = BigDecimal.valueOf(1.1); System.out.println(bd1.subtract(bd2)); } }
Date类的概述
是util包下的,不能导入sql包的
* 类 Date 表示特定的瞬间，精确到毫秒。
构造方：
* public Date()
* public Date(long date)
成员方法：
* public long getTime()
* public void setTime(long time)
import java.util.Date; public class demo6_Date { public static void main(String[] args) { //demo1(); //demo2(); Date d1=new Date(); d1.setTime(1000); System.out.println(d1);//设置毫秒值。改变时间对象 } public static void demo2() { Date d1=new Date(); //通过对象获取毫秒值 System.out.println(d1.getTime()); //通过系统类的方法获取当前时间毫秒值 System.out.println(System.currentTimeMillis()); } public static void demo1() { Date d1=new Date(); //如果没有传参数代表的是当前时间 System.out.println(d1); Date d2=new Date(0); //如果构造方法重参数传的值为0，就代表1970你那 System.out.println(d2); } }
DateFormat类的概述
* DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
SimpleDateFormat构造方法：
* public SimpleDateFormat()
* public SimpleDateFormat(String pattern)
成员方法：
* public final String format(Date date)
* public Date parse(String source)
mport java.util.Date; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; public class Demo7_SimpleDateFormat { public static void main(String[] args) throws ParseException { //demo1(); //demo2(); //demo3(); //将时间字符串转换成日期对象 String str="1994年01月13日 08:08:08"; SimpleDateFormat s1=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); Date d1=s1.parse(str); System.out.println(d1); } public static void demo3() { Date d1=new Date(); SimpleDateFormat s1=new SimpleDateFormat("yyyy/MM/dd/ HH:mm:ss"); System.out.println(s1.format(d1));//将日期对象转换成字符串 } public static void demo2() { Date d1=new Date();//获取当前时间对象 SimpleDateFormat s1=new SimpleDateFormat(); //创建日期格式化类对象 System.out.println(s1.format(d1)); } public static void demo1() { //DateFormat dFormat=new DateFormat(); //dateformat是抽象类，不允许实例化 //DateFormat df1=new SimpleDateFormat(); DateFormat df1=DateFormat.getDateInstance(); //相当于父类引用指向子类对象，右边的方法返回一个子类对象 } }
import java.util.Date; import java.text.ParseException; import java.text.SimpleDateFormat; public class test1 { public static void main(String[] args) throws ParseException { String birthday ="1994年01月13日"; String taday="2019年05月25日"; //定义日期格式化对象 SimpleDateFormat s1=new SimpleDateFormat("yyyy年MM月dd日"); //将日期字符串转换成日期对象 Date d1=s1.parse(birthday); Date d2=s1.parse(taday); //通过日期对象后期时间毫秒值 long time =d2.getTime()-d1.getTime(); //简两个时间毫秒值相减除以1000，在除以60，在除以60，再除以24天 System.out.println(time/1000/60/60/24); } }
Calendar类的概述
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
成员方法
* public static Calendar getInstance()
* public int get(int field)
成员方法
*public void add(int field,int amount)
public final void set(int year,int month,int date)
import java.util.Calendar; public class demo8_CAlendar { public static void main (String args []){ //demo1(); Calendar c1=Calendar.getInstance(); c1.add(Calendar.MONTH,-1); //对指定的字段进行向前减或向后加 c1.set(Calendar.YEAR,2018);//修改指定字段 c1.set(2017,7,8); System.out.println(c1.get(Calendar.YEAR)+"年"+getNum((c1.get(Calendar.MONTH)+1)) +"月"+c1.get(Calendar.DAY_OF_MONTH)+"日"+getWeek(c1.get(Calendar.DAY_OF_WEEK))); } public static void demo1() { Calendar c1=Calendar.getInstance(); System.out.println(c1.get(Calendar.YEAR)); System.out.println(c1.get(Calendar.MONTH)+1);//通过字段后期获取月，月是从0开始编号 System.out.println(c1.get(Calendar.DAY_OF_MONTH)); System.out.println(getWeek(c1.get(Calendar.DAY_OF_WEEK)));//周日第一天 System.out.println(c1.get(Calendar.YEAR)+"年"+getNum((c1.get(Calendar.MONTH)+1)) +"月"+c1.get(Calendar.DAY_OF_MONTH)+"日"+getWeek(c1.get(Calendar.DAY_OF_WEEK))); } public static String getWeek(int week){ String [] arr={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六",}; return arr[week]; } public static String getNum(int num){ if (num>9) { return ""+num; }else{ return "0"+num; } //return num > 9 ? "" +num :"0"+num; } }
import java.util.Calendar; import java.util.Scanner; public class test2 { public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.println("请输入年份"); //int year=sc.nextInt(); String line=sc.nextLine(); int year=Integer.parseInt(line);//将数字字符串转换成数字 boolean b1=getYear(year); System.out.println(b1); } private static boolean getYear(int year) { Calendar c1=Calendar.getInstance(); //设置为那一年的3月1日 c1.set(year, 2, 1); //将日向前减去1 c1.add(Calendar.DAY_OF_MONTH, -1); return c1.get(Calendar.DAY_OF_MONTH)==29; } }
