常见的类
Math类
Math类、常用与执行一些基本数学的运算方法，比如初等指数，对数，平方根，三角函数等等一些数学中常见的运算方法。
下面是一些Math类中常见的方法以及使用的方法。
package demo_otherclass;
public class Demo1_Math {
/*
* Math类概述
* Math 类包含用于执行基本数学运算的方法，如初等指数，对数，平方根，和三角函数
* 成员方法
* public static int abs(int a)
* public static double ceil(double a)
* public static double floor(double a)
* public static int max(int a,int b) (min)
* public static double(double a,double b)
* public static double random()
* public static int round(float) 参数为double
* public static double sqrt(double a)
* */
public static void main(String[] args) {
System.out.println(Math.PI);
System.out.println(Math.abs(-10)); //取绝对值
System.out.println(Math.ceil(12.3)); //向上取整，但是结果是一个double值
System.out.println(Math.ceil(12.99));
System.out.println(Math.floor(12.3)); //向下取整，但是结果是一个double值
System.out.println(Math.floor(12.99));
//获取两个数的最大值
System.out.println(Math.max(10,20));
//前面的数是底数，后面的数是指数
System.out.println(Math.pow(2, 3));
//生成0.0到1.0之间的任意小数，包括0.0，不包括1.0
System.out.println(Math.random());
//四舍五入
System.out.println(Math.round(12.3f));
System.out.println(Math.round(12.9f));
//开平方数
System.out.println(Math.sqrt(4));
System.out.println(Math.sqrt(2));
System.out.println(Math.sqrt(3));
}
}
Random类
Random类是获取随机数的一个类，虽然Math类中存在一个方法是获取随机数的，但Math类中的random方法只能获取0 到 1.0之间的小数，而Random类可以获取更大的数。
package demo_otherclass;
import java.util.Random;
public class Demo2_Random {
/*
*
* */
public static void main(String[] args) {
Random r = new Random();
for(int i = 0; i < 2;i++) {
System.out.println(r.nextInt());
}
Random r1 = new Random(1); //每次运行结果是一样的
for(int i = 0;i < 2;i++) {
System.out.println(r1.nextInt());
}
int n = 100;
for(int i = 0;i < 10;i++) {
System.out.println(r.nextInt(n)); //生成0-n的随机数，包含0，不包含n
}
}
}
以上代码中，当Random类无参构造时，将会获取随机值，但每次运行结果都会不相同，若为有参构造，虽然获取的是随机值，但每次的运行结果都是相同的，在 nextInt() 方法中，当没有参数时，就会获取 int 类型的随机值一个，但若是有参数n，则会获取0 ~ n 范围内的一个值。
System类
System类包含了一些常用的方法，比如我们经常使用的输出、语句就是System类中的方法。下面这是几个System类中的方法。
package demo_otherclass;
public class Demo3_System {
/*
* System类的概述
* System类包含一些有用的类字段和方法，它不能被实例化
* 成员方法
* public static void gc() //运行垃圾回收器
* public static void exit(int status) //
* public static long currentTimeMillis() //
* public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) //
* */
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
}
public static void demo4() {
int[] src = {11,22,33,44,55};
int[] dest = new int[8];
System.arraycopy(src, 0, dest, 0, src.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); //非0状态是异常终止，退出jvm
System.out.println("12123");
}
public static void demo1() {
for(int i = 0;i < 100;i++) {
new Demo();
System.gc();
}
}
}
class Demo { //在一个源文件中，不允许定义两个public 修饰的类
@Override
public void finalize() {
System.out.println("垃圾被清扫了");
}
}
BigInteger类
BigInteger’类通常是用来计算超过 int 类型的数。BigInteger类构造是时传的参数应该为一个字符串， 下面的代码介绍了几个BigInteger类中的常用方法，比如常见的加、减、乘、除等。
package demo_otherclass;
import java.math.BigInteger;
public class Demo4_BigInteger {
/*
* 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 static void main(String[] args) {
String s = "1234567890987654321123";
BigInteger b1 = new BigInteger("100");
BigInteger b2 = new BigInteger("2");
System.out.println(b1.add(b2)); //加
System.out.println(b1.subtract(b2)); //减
System.out.println(b1.multiply(b2)); //乘
System.out.println(b1.divide(b2)); //除
BigInteger[] arr = b1.divideAndRemainder(b2); //取除数和余数
for(int i = 0 ;i < arr.length;i++) {
System.out.println(arr[i]);
}
}
}
BIgDecimal类
由于计算机是二进制存储数据，所以一些十进制的小数不能精确的存储。但BIgDecimal类解决了这个问题，使我们可以正确的表示这些小数。
下面的代码介绍了这个类的一些方法。
package demo_otherclass;
import java.math.BigDecimal;
public class Demo5_BigDecimal {
/*
* 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)
*
* */
public static void main(String[] args) {
System.out.println(2.0 - 1.1); //不能正确的表示
BigDecimal bd1 = new BigDecimal("2.0"); //通过传入字符串，推荐使用
BigDecimal bd2 = new BigDecimal("1.1");
BigDecimal bd3 = BigDecimal.valueOf(2.0);
BigDecimal bd4 = BigDecimal.valueOf(1.1); //调用静态方法valueOf()
System.out.println(bd1.subtract(bd2));
System.out.println(bd3.subtract(bd4));
}
}
Date类、SimpleDateFormat类和Calender类
这几个类都是表示日期的几个类，接下来的代码介绍了这几个类的常用方法。
Date类
package demo_otherclass;
import java.util.Date;
public class Demo6_Date {
/*
* Date 类的概述
* 类Date 表示特定的瞬间，精确到毫秒
* 构造方法
* public Date()
* public Date(long date)
* 成员方法
* public long getTime()
* public void setTime(long time)
* */
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年1月1日
System.out.println(d2);
}
}
SimpleDateFormat类
package demo_otherclass;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo7_SimpleDateFormat {
/*
* DateFormat类的概述
* DateFormat 是日期、时间格式化子类的抽象类，他以语言无关的方式格式化解析日期或时间。是抽象类，所以使用其子类
* SimpleDateFormat的构造方法
* public SimpleDateFormat()
* public SimpleDateFormat(String pattern)
*
* 成员方法
* public final String format(Date date)
* public Date parse(String source)
*
*
* */
public static void main(String[] args) throws ParseException {
//demo1();
//demo2();
//demo3();
//将时间字符串转换成时间对象
String s = "2000年08月08日 08:08:08";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = sdf.parse(s);
System.out.println(d);
}
public static void demo3() {
Date d = new Date(); //获取当前时间对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); //创建日期格式化对象
System.out.println(sdf.format(d)); //将日期对象转换为字符串
}
public static void demo2() {
Date d = new Date(); //获取当前时间对象
SimpleDateFormat sdf = new SimpleDateFormat(); //创建日期格式化对象
System.out.println(sdf.format(d));
}
public static void demo1() {
//DateFormat df = new DateFormat(); //是抽象类，不允许被实例化
DateFormat df1 = DateFormat.getDateInstance(); //相当于父类应用指向子类对象，右边的方法返回一个子类
}
}
Calender类
package demo_otherclass;
import java.util.Calendar;
public class Demo8_Calendar {
/*
* 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)
* */
public static void main(String[] args) {
//demo1();
Calendar c = Calendar.getInstance(); //父类引用指向子类对象
c.add(Calendar.YEAR, 1);
c.add(Calendar.MONTH, -1); //对指定的字段进行向前减或向后加
System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH) + 1))
+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
c.set(Calendar.YEAR, 2000); //修改对应字段
System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH) + 1))
+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
c.set(2000,7,8);
System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH) + 1))
+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
}
public static void demo1() {
Calendar c = Calendar.getInstance(); //父类引用指向子类对象
System.out.println(c);
System.out.println(c.get(Calendar.YEAR)); //通过字段获取年
System.out.println(c.get(Calendar.MONTH)); //通过字段获取月，月是从0开始编号的
System.out.println(c.get(Calendar.DAY_OF_MONTH)); //月中第几天
System.out.println(c.get(Calendar.DAY_OF_WEEK)); //周日是第一天，周六是最后一天
System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH) + 1))
+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
}
/*
* 将星期存储表中进行查表
* 1.返回值类型String
* 2.参数列表int week
*
* */
public static String getWeek(int week) {
String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return arr[week];
}
/*
* 如果是个位数字，前面补0
* 1.返回值类型String类型
* 2.参数列表，int num
* */
public static String getNum(int num) {
if(num > 9) {
return "" + num;
}else {
return "0" + num;
}
}
}
这是一个小练习。算一下从自己出生到现在有多少天？
package Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class Test2 {
/*
* 需求：算一下你来到这个世界多少天？
*
* */
public static void main(String[] args) throws ParseException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的生日:");
String s1 = sc.nextLine();
System.out.println("请输入今天的日期：");
String s2 = sc.nextLine();
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
Date d1 = sdf.parse(s1);
Date d2 = sdf.parse(s2);
long time = d2.getTime() - d1.getTime();
System.out.println(time / 1000 / 60 / 60 / 24 );
}
}
正则表达式
正则表达式是指一个用来描述或匹配一系列符合某个语法规则的字符串，其实就是一种规则，有着自己特殊的应用、
作用举例：比如注册邮箱，邮箱有用户名和密码，一般会对其限制长度，这个限制长度的事请就是正则表达式所做的。
这是一个小小的举例：
package Demo_regex;
import java.util.Scanner;
public class Demo1_Regex {
/*
* 正则表达式
* 是指一个用来描述或匹配一系列符合某个语法规则的字符串的单个字符串，其实就是一种规则，有自己特殊的应用
* 作用：比如注册邮箱，邮箱有用户名和密码，一般会对其限制长度，这个限制长度的事情就是正则表达式做的
*
*
* */
public static void main(String[] args) {
/*
* 需求：校验QQ号码
* 1.要求必须是5-15位数字
* 2.0不能开头
* 3.必须都是数字
* */
Scanner sc = new Scanner(System.in);
String qq = sc.nextLine();
//System.out.println(checkQQ(qq));
String regex = "[1-9]\\d{4,14}";
System.out.println(qq.matches(regex));
}
public static boolean checkQQ(String qq) {
boolean flag = true; //若qq不符合要求，将flag置为false
if(qq.length() >= 5 && qq.length() <= 15) {
if(!qq.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;
}
}else {
flag = false;
}
return flag;
}
}
知道了什么是正则表达式，我们就要学习正则表达式的规则。接下来的代码中就介绍了正则表达式的规则：
package Demo_regex;
public class Demo2_Regex {
/*
* [abc] a,b,c(简单类)
* [^abc]任何字符，除了a，b，c（否定）
* [a-zA-Z]a 到 z或A 到 Z，两头的字母包括在内（范围）
* [a-d[m-p]]a 到 d 或 m 到 p：[a-dm-p](并集)
* [a-z&&[def]] def(交集)
* [a-z&&[^bc]] a 到 z ，除了b，c：[ad-z](减去)
* [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z](减去)
*
* */
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
//demo5();
//demo6();
//demo7();
}
public static void demo7() {
String regex = "[a-z&&[^m-p]]";
System.out.println("a".matches(regex));
System.out.println("m".matches(regex));
System.out.println("z".matches(regex));
System.out.println("n".matches(regex));
}
public static void demo6() {
String regex = "[a-z&&[^bc]]";
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("l".matches(regex));
}
public static void demo5() {
String regex = "[a-z&&[def]]";
System.out.println("a".matches(regex));
System.out.println("d".matches(regex));
}
public static void demo4() {
String regex = "[a-d[m-p]]";
System.out.println("a".matches(regex));
System.out.println("n".matches(regex));
System.out.println("e".matches(regex));
}
public static void demo3() {
String regex = "[a-zA-Z]";
System.out.println("a".matches(regex));
System.out.println("z".matches(regex));
System.out.println("A".matches(regex));
System.out.println("Z".matches(regex));
System.out.println("l".matches(regex));
System.out.println("%".matches(regex));
System.out.println("1".matches(regex));
}
public static void demo2() {
String regex = "[^abc]";
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("c".matches(regex));
System.out.println("d".matches(regex));
System.out.println("1".matches(regex));
System.out.println("%".matches(regex));
System.out.println("10".matches(regex)); //10代表1字符和0字符，不是单个字符
}
public static void demo1() {
String regex = "[abc]";
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("c".matches(regex));
System.out.println("d".matches(regex));
System.out.println("e".matches(regex));
System.out.println("%".matches(regex));
}
}
package Demo_regex;
public class Demo3_Regex {
/*
* . 任何字符
* \d 数字：[0-9]
* \D 非数字：[^0-9]
* \s 空白字符：[ \t\n\x0B\f\r]
* \S 非空白字符[^\s]
* \w 单词字符：[a-zA-Z_0-9]
* \W 非单词字符：[^\w]
* */
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
//demo5();
//demo6();
//demo7();
}
public static void demo7() {
String regex = "\\W";
System.out.println("a".matches(regex));
System.out.println("1".matches(regex));
System.out.println("_".matches(regex));
System.out.println("%".matches(regex));
}
public static void demo6() {
String regex = "\\w";
System.out.println("a".matches(regex));
System.out.println("1".matches(regex));
System.out.println("_".matches(regex));
System.out.println("%".matches(regex));
}
public static void demo5() {
String regex = "\\S";
System.out.println(" ".matches(regex));
System.out.println(" ".matches(regex));
System.out.println("a".matches(regex));
}
public static void demo4() {
String regex = "\\s";
System.out.println(" ".matches(regex));
System.out.println(" ".matches(regex)); //一个tab键
System.out.println(" ".matches(regex)); //四个空格
}
public static void demo3() {
String regex = "\\D";
System.out.println("0".matches(regex));
System.out.println("a".matches(regex));
System.out.println("9".matches(regex));
}
public static void demo2() {
String regex = "\\d";
System.out.println("0".matches(regex));
System.out.println("a".matches(regex));
System.out.println("9".matches(regex));
}
public static void demo1() {
String regex = ".";
System.out.println("a".matches(regex));
System.out.println("ab".matches(regex));
}
}
package Demo_regex;
public class Demo4_Regex {
/*
* Greedy
* X? X,一次或一次没有
* X*X，零次到多次
* X + X，一次或多次
* X{n} X,恰好n次
* X{n,} X,至少n次
* X[n,m] X,至少n次，但不超过m次
* */
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
//demo5();
//demo6();
}
public static void demo6() {
String regex = "[abc]{5,15}";
System.out.println("abc".matches(regex));
System.out.println("abcab".matches(regex));
System.out.println("abcabcabcabc".matches(regex));
System.out.println("abcabcabcabcabc".matches(regex));
System.out.println("abcabcabcabcabcabc".matches(regex));
}
public static void demo5() {
String regex = "[abc]{5,}";
System.out.println("abcab".matches(regex));
System.out.println("abcabcabc".matches(regex));
System.out.println("abca".matches(regex));
System.out.println("abcababcabcabcabc".matches(regex));
}
public static void demo4() {
String regex = "[abc]{5}";
System.out.println("abcab".matches(regex));
System.out.println("abcabcabc".matches(regex));
System.out.println("abca".matches(regex));
System.out.println("abcababcabcabcabc".matches(regex));
}
public static void demo3() {
String regex = "[abc]+";
System.out.println("".matches(regex));
System.out.println("a".matches(regex));
System.out.println("abc".matches(regex));
System.out.println("aaaaaaaaa".matches(regex));
}
public static void demo2() {
String regex = "[abc]*";
System.out.println("".matches(regex));
System.out.println("abc".matches(regex));
System.out.println("a".matches(regex));
System.out.println("d".matches(regex));
}
public static void demo1() {
String regex = "[abc]?";
System.out.println("a".matches(regex));
System.out.println("b".matches(regex));
System.out.println("c".matches(regex));
System.out.println("d".matches(regex));
System.out.println("".matches(regex));
}
}
接下来介绍几个正则表达式的使用场景。
我们可以用正则表达式及那个字符串进行分割，使用String类中的 split() 方法。
package Demo_regex;
public class Demo5_Spilt {
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]);
}
System.out.println();
s = "张三.李四.王五";
arr = s.split("\\.");
for(int i = 0;i < arr.length;i++) {
System.out.println(arr[i]);
}
}
}
正则表达式还有替换功能：
package Demo_regex;
public class Demo6_ReplaceAll {
/*
* 正则表达式的替换功能
* String 类的功能：public String replaceAll(String regex,String replacement)
* */
public static void main(String[] args) {
String s = "wo11ai232433heima";
String regex = "\\d";
String s2 = s.replaceAll(regex,"");
System.out.println(s2);
}
}
正则表达式还有一个非常有用的功能就是分组功能。有了分组就可以处理好多问题：
package Demo_regex;
public class Demo7_regex {
/*
* 正则表达式的分组功能
* 捕获组可以通过从左到右计算其开括号来编号。
* */
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
}
public static void demo3() {
String s = "我我...我...我.要...要要...要学....学学..学.编.程.程.程..程";
String s2 = s.replaceAll("\\.+", "");
String s3 = s2.replaceAll("(.)\\1+", "$1"); //$1表示代表第一组的内容
System.out.println(s3);
}
public static void demo2() {
String regex = "(.)\\1+"; //+代表前面出现一次或多次
String s = "sdqqfgkkkhjppppkl";
String[] sArr = s.split(regex);
for(int i = 0;i < sArr.length;i++) {
System.out.println(sArr[i]);
}
}
public static void demo1() {
String regex = "(.)\\1(.)\\2"; //\\1表示第一组再出现一次,\\2表示第二组再出现一次
System.out.println("快快乐乐".matches(regex));
System.out.println("快乐快乐".matches(regex));
regex = "(..)\\1";
System.out.println("快乐快乐".matches(regex));
System.out.println("快快乐乐".matches(regex));
}
}
正则表达式还有获取功能：
package Demo_regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Demo8_Pattern {
/*
* Pattern p = Pattern.complie("a*b");
* Matcher m = p.mattcher("aaaaab");
* boolean a = m.matches();
*
* 需求：把一个字符串中的手机号码获取出来( demo2(), demo3() )
* */
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
}
public static void demo3() {
String s = "我的手机号码是13345678910，曾经用过15236478912，还用过17365428792";
String regex = "1[3578]\\d{9}"; //手机号码的正则表达式
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
while(m.find()) {
System.out.println(m.group());
}
}
public static void demo2() {
String s = "我的手机号码是13345678910，曾经用过15236478912，还用过17365428792";
String regex = "1[3578]\\d{9}"; //手机号码的正则表达式
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
boolean b = m.find();
System.out.println(b);
String s1 = m.group();
System.out.println(s1);
b = m.find();
System.out.println(b);
s1 = m.group();
System.out.println(s1);
b = m.find();
System.out.println(b);
s1 = m.group();
System.out.println(s1);
}
public static void demo1() {
Pattern p = Pattern.compile("a*b"); //获取正则表达式
Matcher m = p.matcher("aaaaab"); //获取匹配器
boolean b = m.matches(); //看是否能匹配，匹配就返回true
System.out.println(b);
System.out.println("aaaaab".matches("a*b")); //与上面结果一样
}
}
链表
学了好几周Java了，一直不知道链表应该如何去写，在本周学习了Java中如何去实现链表，我发现Java中的链表其实是很容易就能够实现了。废话不多说，它的原理和C语言链表的原理是一样的，所以我只展示一下我写的一些链表操作，都是些简单操作。
public class ListNode {
public int val;
public ListNode next;
public ListNode() {
super();
}
public ListNode(int val) {
super();
this.val = val;
}
}
import java.util.Scanner;
public class MyLinkList {
public static ListNode head_insert(ListNode head,int val) {
ListNode temp = new ListNode(val);
temp.next = head.next;
head.next = temp;
return head;
}
public static ListNode tail_insert(ListNode head,int val) {
ListNode temp = new ListNode(val);
ListNode p;
p = head;
while(p.next != null) {
p = p.next;
}
p.next = temp.next;
temp.next = null;
return head;
}
public static ListNode delete_node(ListNode head,int val) {
ListNode temp;
temp = head;
while(temp.next != null) {
if(temp.next.val != val) {
temp = temp.next;
}else {
temp.next = temp.next.next;
}
}
return head;
}
public static ListNode sort_list(ListNode head) {
ListNode a,b,p;
a = head;
p = head.next;
b = p.next;
while(b != null) {
while(a.next.val <= b.val && a.next != b) {
a = a.next;
}
if(a.next == b) {
p = p.next;
}else {
p.next = b.next;
b.next = a.next;
a.next = b;
}
a = head;
b = p.next;
}
return head;
}
public static ListNode reverse_list(ListNode head) {
ListNode a,b,p;
p = head.next;
a = p;
b = a.next;
while(b != null) {
a.next = b.next;
b.next = p;
p = b;
b = a.next;
}
head.next = p;
return head;
}
public static ListNode add_list(ListNode l1,ListNode l2) {
if(l1 == null) return l1;
if(l2 == null) return l2;
l1 = l1.next;
l2 = l2.next;
ListNode head = new ListNode();
ListNode temp;
temp = head;
temp.next = null;
while(l1 != null && l2 != null) {
if(l1.val > l2.val) {
temp.next = l2;
l2 = l2.next;
temp = temp.next;
temp.next = null;
}else {
temp.next = l1;
l1 = l1.next;
temp = temp.next;
temp.next = null;
}
}
if(l1 != null) temp.next = l1;
if(l2 != null) temp.next = l2;
return head;
}
public static ListNode create_List() {
ListNode head = new ListNode();
head.next = null;
Scanner sc = new Scanner(System.in);
int val = sc.nextInt();
while(val != -1) {
head = head_insert(head, val);
val = sc.nextInt();
}
return head;
}
public static void print_list(ListNode head) {
ListNode temp = head.next;
while(temp != null) {
System.out.print(temp.val + " ");
temp = temp.next;
}
System.out.println();
}
}
这周还学习了集合，但集合没有学完，所以就先不写集合了。