【无标题】

最新推荐文章于 2026-01-06 12:00:34 发布

原创最新推荐文章于 2026-01-06 12:00:34 发布 · 155 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #排序算法

文章介绍了Java中的冒泡排序算法，展示了如何使用Arrays工具类进行数组排序，以及Integer类的基本操作，包括int与String的转换。此外，还讲解了日期类Date的基本用法和SimpleDateFormat用于日期格式化的功能，以及Calendar类在处理日期和时间方面的应用。

Arrays

冒泡排序

如果有n个数据进行排序，总共需要比较n-1次

每一次比较完毕，下一次的比较就会少一个数据参与

package one;

import java.util.Arrays;

/*
  冒泡排序：
        一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
        依次对所有的数据进行操作，直至所有的数据按要求完成排序
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 63, 68, 23, 56};
        System.out.println("排序前：" + arrayToString(arr));

        //排序比较

        for (int x = 0; x < arr.length - 1; x++) {
            for (int i = 0; i < arr.length-1-x; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }

        System.out.println("排序后：" + arrayToString(arr));


    }


    private static String arrayToString(int[] arr) {
        /*
        StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器，
        这里的可变指的是StringBuilder对象中的内容是可变的
        */
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }

}

Arrays类的概述和常用方法

arrays类包含用于操作数组的各种方式

方法名	说明
public static String toString（int[] s）	返回指定数组的内容的字符串表示形式
public static String sort（int[] s）	按照数字顺序排列指定的数组

工具类的设计思想：

构造方法用private修饰

成员用public static修饰

package two;

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {24, 58, 23, 789, 53, 86};
        System.out.println("排序前：" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));

    }
}

基本类型包装类

基本类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer类的概述和使用

Integer：包装一个对象中的原始类型int的值

方法名	说明
public static Integer valueOf(int i)	返回表示指定的int值的Integer实例
public static Integer valueOf(String s)	返回一个保存指定值的Integer对象string

package 基本类型包装类.item02;

public class IntegerDemo {
    public static void main(String[] args) {
        /*
        Integer i1 = new Integer(1900);
        System.out.println(i1);

        Integer i2 = new Integer("100");
        System.out.println(i2);

         */
        Integer i1 = Integer.valueOf(100);
        System.out.println(i1);

//        Integer i2 = Integer.valueOf("abv");//For input string: "abv"
        Integer i2 = Integer.valueOf("100");
        System.out.println(i2);

    }
}

int和String的相互转换

基本类型包装类的最常见操作就是：用于基本类型和字符串之间的相互转换

int转换为String

static String valueOf(int i)

返回 int参数的字符串表示形式。

String类中的方法

String转换为int

static int parseInt(String s)

将字符串参数解析为带符号的十进制整数。

Integer类中的方法

package 基本类型包装类.item03;

public class IntegerDemo {
    public static void main(String[] args) {
        //int --String
        int number = 100;
//        方式一
        String s1 = "" + number;
//        方式二
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("----------------");

        //方式一
//        String --- integer --- int
        String s3 = "100";
        Integer number2 = Integer.valueOf(s3);
        int numInt = number2.intValue();
        System.out.println(numInt);
        //方式二
        int numInt2 = Integer.parseInt(s3);
        System.out.println(numInt2);
        
    }
}

案例：字符串中的数据排序

需求：有一个字符串："91 27 46 38 50",请写程序实现最终输出结果是：“27 38 46 50 91”

思路：

1、定义一个字符串

2、把字符串中的数字数据存储到一个int类型的数组中

得到字符串中每一个数字数据

String[] split(String regex)

定义一个int数组，把String【】数组中的每一个元素存储到int数组中

static int parseInt(String s)

3、对int数组进行排序

4、对排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现

5、输出结果

package 基本类型包装类.item04;
//需求：有一个字符串："91 27 46 38 50",请写程序实现最终输出结果是：“27 38 46 50 91”
/*
思路：
    1、定义一个字符串
    2、把字符串中的数字数据存储到一个int类型的数组中
        得到字符串中每一个数字数据
        String[]    split(String regex)
        定义一个int数组，把String【】数组中的每一个元素存储到int数组中
        static int    parseInt(String s)
    3、对int数组进行排序
    4、对排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
    5、输出结果
 */

import java.util.ArrayList;
import java.util.Arrays;

public class 字符串中数据排序 {
    public static void main(String[] args) {
        String s1 = "91 27 46 38 50";

        /*
        String[]    split(String regex)
        将此字符串拆分为给定 regular expression的匹配项 。
         */
        String[] s2List = s1.split(" ");
        int[] numArray = new int[s2List.length];

        for (int i = 0; i < s2List.length; i++) {
            int num = Integer.parseInt(s2List[i]);
            numArray[i] = num;
        }
        Arrays.sort(numArray);
     /*   for (int u = 1; u < numArray.length; u++) {

            for (int i = 0; i < numArray.length - 1; i++) {
                if (numArray[i] > numArray[i + 1]) {
                    temp = numArray[i + 1];
                    numArray[i + 1] = numArray[i];
                    numArray[i] = temp;
                }
            }

        }*/
        StringBuilder strb = new StringBuilder();
        for (int i = 0; i < numArray.length; i++) {
            if (i == numArray.length) {
                strb.append(numArray[i]);
            } else {
                strb.append(numArray[i]).append(" ");
            }

        }
        String result = strb.toString();
        System.out.println(result);
    }
}

5.4 自动装箱和拆箱

装箱：把基本数据类型转换为对应的包装类类型

拆箱：把包装类类型转换为对应的基本数据类型

Integer i= 100;//自动装箱

ii +=200;//自动拆箱，自动装箱

注意：在使用包装类类型的时候，如果做操作，最好先判断是否为null

只要是对象，在使用前就必须进行不为null的判断

6.日期类

6.1Date类概述和构造方法

Date代表了一个特定的时间，精确到毫秒

public Date（）	分配一个Date对象，并初始化，以便它代表他被分配的时间，精确到毫秒
public Date（long date）	分配一个Date对象，并将其初始化为从标准基准时间起指定的毫秒数

public class Datedemo01 {
    public static void main(String[] args) {
        //public Date（） 分配一个Date对象，并初始化，以便它代表他被分配的时间，精确到毫秒
        Date date = new Date();
        System.out.println(date);

        //public Date（long date） 分配一个Date对象，并将其初始化为从标准基准时间起指定的毫秒数 1970
        Date date1 = new Date(1000*60*60);
        System.out.println(date1);
    }
}

6.2 Date类的常用方法

public long getTime()	获取的是从日期对象从1970年1月1日00：00：00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

// public long getTime()  获取的是从日期对象从1970年1月1日00：00：00到现在的毫秒值
// public void setTime(long time)
public class demo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date date = new Date();
// public long getTime()  获取的是从日期对象从1970年1月1日00：00：00到现在的毫秒值
        //System.out.println(date.getTime());
//        System.out.println(date.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
//        long time = 1000 * 60 * 60;
        long time = System.currentTimeMillis();//当前时间
        date.setTime(time);
        System.out.println(date);

    }
}

6.3 SimpleDateFormat类概述

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。我们重点学习日期格式化和解析

日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从‘A’到‘Z’以及从‘a’到‘z’引号的字母被解释为表示日期或时间字符串的组建的模式字母

常用的模式字母及对应关系如下：

y 年

M 月

d 日

H 时

m 分

s 秒

public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattem)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

6.5 SimpleDateFormat格式化和解析日期

格式化（从Date到String）

public final String format(Date date): 将日期格式化成日期/时间字符串

解析（从String到Date）

public Date parse (String source): 从给定字符串的开始解析文本以生成日期

public class demo03 {
    public static void main(String[] args) throws ParseException {
        //从Date到String
        Date date = new Date();
//        SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String format = sdf.format(date);
        System.out.println(format);
        System.out.println("----------");
        //从String到Date
        String ss = "2048-08-09 11:11:11";
        //ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

案例：日期工具类

需求：定义一个日期工具类（DateUtils），包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法

思路：

1、定义日期工具类（DateUtils）

2、定义一个方法dateToString，用于把日期转换为指定格式的字符串

返回值类型：String

参数：Date date，String format

3、定义一个方法 stringToDate，用于字符串解析为指定格式的日期

返回值类型：Date

参数：String s，String format

4、定义测试类DateDemo，调用日期工具类中的方法

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //日期转字符串
        Date date = new Date();
        String s = DateUtils.DateToString(date, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s);

        String s2 = DateUtils.DateToString(date, "yyyy年MM月dd日");
        System.out.println(s2);

        String s3 = DateUtils.DateToString(date, "HH:mm:ss");
        System.out.println(s3);
        System.out.println("----------");


        //字符串转日期
        String s4 = "2042-07-09 12:23:21";
        Date date1 = DateUtils.StringToDate(s4, "yyyy-MM-dd HH:mm:ss");
        System.out.println(date1);
    }
}

public class DateUtils {
    private DateUtils() {
    }
    //日期转字符串
        public static String DateToString(Date date,String format){
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
            String s = simpleDateFormat.format(date);
            return s;
        }
    //字符串转日期
    public static Date StringToDate(String s,String format) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
        Date parse = simpleDateFormat.parse(s);
        return parse;
    }
}

6.6 Calendar类概述（日历类）

Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar提供了一个类方法getlnstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化：

Calendar rightNow = Calendar.getInstance();

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();//多态的形式
//        System.out.println(c);

        //public int get(int field)
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

    }
}

public int get(int field)	返回给定日历字段的值。
public abstract void add(int field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段。
public final void set(int year, int month, int date)	设置日历字段中的年月日

public class CalendarDemo {
    public static void main(String[] args) {
        //获取日历类对象
        Calendar instance = Calendar.getInstance();

        //public int get (int field): 返回给定日历字段的值
//        int year = instance.get(Calendar.YEAR);
//        int month = instance.get(Calendar.MONTH) + 1;
//        int date = instance.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");

//• public abstract void add(int field,int amount) 根据日历的规则，将指定的时间量添加或减去给定的日历字段。
        // 需求1： 3年前的今天
//        instance.add(Calendar.YEAR, -3);//减少3年
//        int year = instance.get(Calendar.YEAR);
//        int month = instance.get(Calendar.MONTH) + 1;
//        int date = instance.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");
        //
        //需求2： 10年后的5天前
//        instance.add(Calendar.YEAR, 10);//增加10年
//        instance.add(Calendar.DATE, -5);//减少五天
//        int year = instance.get(Calendar.YEAR);
//        int month = instance.get(Calendar.MONTH) + 1;
//        int date = instance.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");


//• public final void set(int year,int month,int date) 设置日历字段中的年月日
        instance.set(2029, 11, 3);
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH)+1;
        int date = instance.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

    }

}