JavaSE（07）（数组高级操作及日期格式）

最新推荐文章于 2019-07-18 10:07:28 发布
最新推荐文章于 2019-07-18 10:07:28 发布
阅读量430 收藏
点赞数
文章标签： java se 冒泡排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014756517/article/details/50058479
版权 
冒泡排序:
package zz.itheima.arrays;

public class BubbleSort {
    //冒泡排序
    public static void main(String[] args) {
        int score[] = {67, 69, 75, 87, 89, 90, 99, 100};

                 for (int i = 0; i < score.length -1; i++){    //最多做n-1趟排序
                      for(int j = 0 ;j < score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                           if(score[j] < score[j + 1]){    //把小的值交换到后面
                               int temp = score[j];
                               score[j] = score[j + 1];
                               score[j + 1] = temp;
                          }
                      }            
                  System.out.print("第" + (i + 1) + "次排序结果：");
                  for(int a = 0; a < score.length; a++){
                      System.out.print(score[a] + "\t");
                  }
                  System.out.println("");
              }
                  System.out.print("最终排序结果：");
                  for(int a = 0; a < score.length; a++){
                      System.out.print(score[a] + "\t");
             }
          }
}
运行结果：
第1次排序结果：69  75  87  89  90  99  100 67  
第2次排序结果：75  87  89  90  99  100 69  67  
第3次排序结果：87  89  90  99  100 75  69  67  
第4次排序结果：89  90  99  100 87  75  69  67  
第5次排序结果：90  99  100 89  87  75  69  67  
第6次排序结果：99  100 90  89  87  75  69  67  
第7次排序结果：100 99  90  89  87  75  69  67  
最终排序结果：100  99  90  89  87  75  69  67
选择排序：
package zz.itheima.arrays;

public class SelectSort {
    /**
     * 选择排序
     * @param args
     */
    public static void main(String[] args) {
        int[] arr={3,5,1,7,6};

        //从小到大

        for(int j=0;j<arr.length-1;j++)
        {
            for (int i = j+1; i < arr.length; i++) {
                //第1轮    arr[0] arr[i]
                //第2轮   arr[1] arr[i]
                if(arr[j]>arr[i])
                {
                    int temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
运行结果：
1
3
5
6
7
顺序查找：
package zz.itheima.arrays;

public class OrderSearch {
    /**
     * 顺序查找
     * @param args
     */
    public static void main(String[] args) {
        int[] arr={3,5,1,7,6};

        //顺序查找     找7
        boolean flag=false;

        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==7)
            {
                System.out.println("存在");
                flag=true;
                break;
            }
        }
        if(flag==false)
            System.out.println("不存在");
    }
}
运行结果：
存在
二分折半查找：
package zz.itheima.arrays;

public class BinarySearch {
    /**
     * 二分折半查找
     * @param args
     */
    public static void main(String[] args) {
    int[] arr={1,2,3,4,5,6,7,8,9};    //必须有序

        int left=0;
        int right=arr.length-1;

        while (left<=right) {
            //找mid
            //1.mid==目标    找到了
            //2.mid<目标  （缩小包围圈 left  right）
            //3.mid>目标（缩小包围圈 left  right）
            int mid=(left+right)/2;
            if(arr[mid]==8)
            {
                System.out.println("存在");
                break;
            }
            if(arr[mid]<10)
            {
                left=mid+1;
            }
            if(arr[mid]>10)
            {
                right=mid-1;
            }

        }
        if(left>right)
            System.out.println("不存在");
    }
}
运行结果：
存在
测试程序运行时间
package zz.itheima.arrays;

public class TestSystem {
    //测试程序执行了多长时间
    public static void main(String[] args) {

    int[] arr={3,5,1,7,6,9,10,67,34,55,99};

        long begin=System.currentTimeMillis();
        //从小到大
        for(int j=0;j<arr.length-1;j++)
        {
            for (int i = 0; i < arr.length-1-j; i++) {
                if(arr[i]>arr[i+1])
                {
                    int temp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            }
        }
        long end=System.currentTimeMillis();

        System.out.println(end-begin);
    }
}
数字格式化：
package zz.itheima.arrays;

import java.text.NumberFormat;

public class TestNumberFormat {

    public static void main(String[] args) {
        double a=10.98;
        System.out.println(a*1.1);

        NumberFormat nf=NumberFormat.getInstance();
        nf.setMaximumFractionDigits(1);//设置某个数的小数部分中所允许的最大数字位数
        System.out.println(nf.format(a*1.1));
    }
}
运行结果：
12.078000000000001
12.1
日期格式化：
package zz.itheima.arrays;

import java.text.DateFormat;
import java.util.Date;
import java.util.Scanner;

public class TestDateFormat {

    public static void main(String[] args) throws Exception {
        //public static final DateFormat getDateInstance()，获取日期格式器，该格式器具有默认语言环境的默认格式化风格。
        Date now=new Date();
        System.out.println(now);

        DateFormat df1=DateFormat.getDateInstance();
        String s=df1.format(now);
        System.out.println(s);

//      public static final DateFormat getDateInstance(int style)，获取日期格式器，该格式器具有默认语言环境的指定格式化风格。
        DateFormat df2=DateFormat.getDateInstance(DateFormat.SHORT);
        s=df2.format(now);
        System.out.println(s);
//
//      public static final DateFormat getDateTimeInstance()，获取日期/时间格式器，该格式器具有默认语言环境的默认格式化风格。
        DateFormat df3=DateFormat.getDateTimeInstance();
        s=df3.format(now);
        System.out.println(s);

//      public static final DateFormat getDateTimeInstance(int dateStyle, int timeStyle)，获取日期/时间格式器，
               // 该格式器具有默认语言环境的指定日期和时间格式化风格。
        DateFormat df4=DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.SHORT);
        s=df4.format(now);
        System.out.println(s);
//      public static final DateFormat getTimeInstance()，获取时间格式器，该格式器具有默认语言环境的默认格式化风格。
//
//      public static final DateFormat getTimeInstance(int style)，获取时间格式器，该格式器具有默认语言环境的指定格式化风格。
//
//      public final String format(Date date)将一个 Date对象格式化为日期/时间字符串。

//      public Date parse(String source)，将字符串解析为Date对象。字符串中日期时间格式必须跟格式化器的风格一致
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你的生日：");
        String birString=sc.nextLine();

        DateFormat df5=DateFormat.getDateInstance();
        Date birDate=df5.parse(birString);  
        System.out.println(birDate);
    }
}
运行结果：
Thu Nov 26 17:03:42 CST 2015
2015-11-26
15-11-26
2015-11-26 17:03:42
2015年11月26日 星期四 下午5:03
请输入你的生日：
时间测试：
package zz.itheima.arrays;

import java.text.DateFormat;
import java.util.Date;

public class TestDate {

    public static void main(String[] args) {
        Date now=new Date();
        System.out.println(now);

        System.out.println(now.getTime());

        System.out.println(DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.SHORT).format(now));
    }
}
运行时间：
Thu Nov 26 17:04:40 CST 2015
1448528680749
2015年11月26日 星期四 下午5:04
测试日历：
package zz.itheima.arrays;

import java.util.Calendar;
import java.util.Date;

public class TestCalender {
    //日历类测试
    public static void main(String[] args) {

//      public static Calendar getInstance()，使用默认时区和语言环境获得一个日历对象(Calendar类是抽象类)
        Calendar c=Calendar.getInstance();
        System.out.println(c);

//      public int get(int field)返回日历对象中给定字段的值
        System.out.println(c.get(Calendar.HOUR));

//      public void set(int field, int value)，设置日历对象中的给定字段的值
        c.set(Calendar.YEAR,2015);

//      public final Date getTime()，返回日历中的日期时间对象
        Date d=c.getTime();
        System.out.println(d);
//      public final void setTime(Date date)，设置日历中的日期时间对象
    }
}
运行结果：
java.util.GregorianCalendar[time=1448528724370,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2015,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=26,DAY_OF_YEAR=330,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=5,HOUR_OF_DAY=17,MINUTE=5,SECOND=24,MILLISECOND=370,ZONE_OFFSET=28800000,DST_OFFSET=0]
5
Thu Nov 26 17:05:24 CST 2015
数组类进行测试：
package zz.itheima.arrays;

import java.util.Arrays;

public class TestArrays {
    /**
     * 对数组类进行测试
     * @param args
     */
    public static void main(String[] args) {
//      public static void sort(xxx[]  a) ，对数组a进行升序排序
        int[] arr={4,6,1,8,3,9};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
//      public static int binarySearch(xxx[] a , xxx key)，通过二分(折半)查找法搜索数组a中的key
        int num=0;
        int result=Arrays.binarySearch(arr, num);
        System.out.println(result);
//      public static xxx[] copyOf(xxx[] a , int newLength)，通过复制数组a的newLength长度的数据到新数组
        int[] temp=Arrays.copyOf(arr, 3);
        for (int i = 0; i < temp.length; i++) {
            System.out.print(temp[i]+" ");
        }
        System.out.println();
//      public static xxx[] copyOfRange(xxx[] a , int from , int to)，通过复制数组a的指定范围的数据到新数组
        temp=Arrays.copyOfRange(arr, 2, 4);
        for (int i = 0; i < temp.length; i++) {
            System.out.print(temp[i]+" ");
        }
        System.out.println();
//      public static boolean equals(xxx[] a1 , xxx[] a2)，比较a1和a2两个数组是否一样
        int[] arr2={4,6,1,8,3,9};
        System.out.println(Arrays.equals(arr, arr2));//顺序不一样也不是同一个数组
    }
}
运行结果：
1 3 4 6 8 9 
-1
1 3 4 
4 6 
false
数组存放对象：
package zz.itheima.arrays;

public class TestArray {

    public static void main(String[] args) {
        //数组可以是自定义类型,数组存放了对象
        int[] arr={4,2,8,1,7};
        Book[] arrBooks=new Book[3];
        arrBooks[0]=new Book("adf",100.10);
        arrBooks[1]=new Book("aasddf",10560.10);
        arrBooks[2]=new Book("aasdfdf",10560.10);

        //数组位置交换
        int temp=arr[1];
        arr[1]=arr[3];
        arr[3]=temp;
    }
}
两个日期时间差：
package zz.itheima.arrays;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;




public class Demo2 {  

    /** 
     * 两个日期时间差
     * @param args 
     * @throws ParseException  
     */  
    public static void main(String[] args) throws ParseException {  
        // TODO Auto-generated method stub  
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        Date d1=sdf.parse("2015-07-13 10:10:10");  
        Date d2=sdf.parse("2015-11-26 00:00:00");  
        System.out.println(daysBetween(d1,d2));  

        System.out.println(daysBetween("2015-07-13 10:10:10","2015-11-26 00:00:00"));  
    }  

    /**  
     * 计算两个日期之间相差的天数  
     * @param smdate 较小的时间 
     * @param bdate  较大的时间 
     * @return 相差天数 
     * @throws ParseException  
     */    
    public static int daysBetween(Date smdate,Date bdate) throws ParseException    
    {    
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
        smdate=sdf.parse(sdf.format(smdate));  
        bdate=sdf.parse(sdf.format(bdate));  
        Calendar cal = Calendar.getInstance();    
        cal.setTime(smdate);    
        long time1 = cal.getTimeInMillis();                 
        cal.setTime(bdate);    
        long time2 = cal.getTimeInMillis();         
        long between_days=(time2-time1)/(1000*3600*24);  

       return Integer.parseInt(String.valueOf(between_days));           
    }    

    /** 
    *字符串的日期格式的计算 
    */  
    public static int daysBetween(String smdate,String bdate) throws ParseException{  
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");  
        Calendar cal = Calendar.getInstance();    
        cal.setTime(sdf.parse(smdate));    
        long time1 = cal.getTimeInMillis();                 
        cal.setTime(sdf.parse(bdate));    
        long time2 = cal.getTimeInMillis();         
        long between_days=(time2-time1)/(1000*3600*24);  

       return Integer.parseInt(String.valueOf(between_days));     
    }  
} 
运行结果：
136
136
固定格式日历：
package zz.itheima.arrays;

import java.util.Calendar;

public class Demo1 {

    public static void main(String[] args) {
        // 练习：在控制台输出当前时间，格式为“2014-1-29 14:24:55”
        Calendar c = Calendar.getInstance();//得到日历对象
        //分别得到年月日和时分秒就可以了
        int year=c.get(Calendar.YEAR);
        int month=c.get(Calendar.MONTH)+1;
        int day=c.get(Calendar.DAY_OF_MONTH);
        int hour=c.get(Calendar.HOUR);
        int minute=c.get(Calendar.MINUTE);
        int sec=c.get(Calendar.SECOND);

        System.out.println(year+"-"+month+"-"+day+" "+hour+":"+minute+":"+sec);
    }
}
运行结果：
2015-11-26 5:9:7
Book类：
package zz.itheima.arrays;

public class Book {
    private String name;
    private double price;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public Book(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }
    public Book() {
        super();
    }
}
Lqc_javaEngineer
关注
JavaSE基础07：数组
x1392267598的博客
07-29 148
数组 概念 同一种类型数据的集合。其实数组就是一个容器。 数组的好处 可以自动给数组中的元素从0开始编号，方便操作这些元素。 格式1： 元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例：int[] arr = new int[5]; 格式2： 元素类型[] 数组名 = new 元素类型[]{元素，元素，……}; int[] arr = new int[]...
史上最全 javaSE基础和高级面试题整理
陈先生
02-14 2666
javaSE基础和高级 一.面向对象基础 1.面向对象的特征有哪些方面？ 面向对象的编程语言有封装、继承 、多态、抽象等4个主要的特征。 封装： ​ 面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，把握一个原则：把对同一事...
JAVA字符串格式化——format()时间日期格式化
werewofe的专栏
01-02 726
例子：   Date date = new Date();//创建Date对象date   String year = String.format("%tY", date);   String month = String.format("%tB", date);   String day = String.format("%td", date);   System.out.printl
Java初认识之——java数组、Java 日期时间
csdn_wanziooo的博客
07-13 2134
Java 数组声明数组变量：dataType[] arrayRefVar;           double[] myList;创建数组：java语言使用new操作符来创建数组，语法如下：arrayRefVar = new datatype[arraySize];上面的语法语句做了两件事情：1.使用dataType[arraySize]创建了一个数组；2.把新创建的数字的引用复制给变量arrayR...
java 时间操作 格式化 时区 系统时间
jiaoxueli的专栏
04-17 4199
 学习了java时间的各种操作，总结如下类，大家可供参考。 package xiaojiao.date;import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Calendar;import java.sql.Timestamp;import
java常用类-java日期处理类
qq_35971362的博客
10-11 424
java常用类-java日期处理类 Date类 Date类是jdk给我们提高的标准日期类，在java.util包下； 给下示例代码： 1 2 3 4 5 6 7 8 9 10 11 package com.java1234.chap05.sec01;  
正宗 ~ 冒泡排序
u010061691的专栏
04-29 421
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 　　冒泡排序算法的运作如下:  比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作
javase测验题及答案 (1).zip
08-07
这个压缩包文件“javase测验题及答案 (1).zip”显然包含了针对Java SE基础知识的测验题目和答案，对于学习和复习Java SE的开发者来说非常有用。让我们深入探讨一下这些文件可能涵盖的Java SE关键知识点。 首先，...
javase总结
05-08
5. **数组**：理解一维、二维数组的概念，以及数组操作。 三、面向对象 1. **类与对象**：理解类的定义、对象的创建与使用。 2. **封装**：通过访问修饰符实现数据的隐藏和保护。 3. **继承**：学习单一继承和多层...
JavaSE基础学习笔记2020.pdf
03-06
7. Calendar类：Java提供了一个用于日期时间操作的类。 8. 集合框架：包括Collection和Map等接口及其实现类，用于存储对象集合。 9. Iterator迭代器：用于遍历集合框架中的元素。 10. 增强型for循环：Java 5引入的...
JavaSE笔试程序题（20180307）
06-13
JavaSE笔试程序题涵盖了许多核心Java编程概念，包括设计模式、数据结构、算法、多线程、I/O操作以及字符串处理等。以下是这些题目中涉及的知识点详解： 1. **Singleton模式**：确保一个类只有一个实例，常用于配置...
像java一样使用js contains 数组包含方法 实践笔记
JanelSirry's Blog
09-05 2467
在JS中，判断一个数组中是否包含某个值，一般用indexOf(),今天我们用contains，跟写java一样判断数组包含某个值，但是js原生是没有数组的contains，所以我们要先自己封装一下，给Array增加contains()方法了 封装contains Array.prototype.contains = function(val) { for (var i = 0; ...
json数组按照日期先后排序
weixin_30849403的博客
07-09 1107
var allMyApp = [ {"startDate": "2018-07-07 12:30:00",'name':'aa'}, {"startDate": "2018-07-09 12:30:00",'name':'bb'}, {"startDate": "2018-07-05...
利用冒泡排序对日期进行排序
金州饿霸吃不饱的博客
09-18 1023
package jave; /*日期排序*/ public class DataSort { public static void main(String[] args) { Date[] days = new Date[5]; days[0] = new Date(2006, 5, 4); days[1] = new Date(2006, 7, 4); days[2] ...
java 8 对JSONArray 按指定字段排序，升序和倒序，经典
韩暄
07-18 6539
文章目录java 8 对JSONArray 按指定字段排序，升序和倒序，经典一、comparing 方法的使用二、reversed 方法的使用 java 8 对JSONArray 按指定字段排序，升序和倒序，经典 以前在内存中用大数据量的排序不论使用冒泡排序还是使用Collections.sort效率都相当低下，现如今Java 8 出现了Comparator 首先这并不是一个方法，而是一个接口 ...
第四周实践课-课堂笔记.pdf
09-16
第四周实践课-课堂笔记
第5周玩转案例分析(2).pdf
09-16
第5周玩转案例分析(2)
第7周实践课安排.pdf
09-16
第7周实践课安排
基于MATLAB m编程的发动机最优工作曲线计算程序（OOL），在此工作曲线下，发动机燃油消耗最小 文件内含：1、发动机最优工
最新发布
09-16
基于MATLAB m编程的发动机最优工作曲线计算程序（OOL），在此工作曲线下，发动机燃油消耗最小。 文件内含：1、发动机最优工作曲线计算程序m文件；2、发动机万有特性数据excel文件 注：附赠电机效率map绘制程序（m程序）与对应电机效率map数据（excel ）
JavaSE入门详解：从基础到高级特性
"JavaSE学习笔记整理，涵盖了Java基础、数据类型、数组、类和对象、访问权限、面向对象特性、系统类、异常处理、集合框架等核心概念。此外，还涉及了Java命令行工具的使用，如javac、java、javadoc、javap以及环境...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值