头像

夏陌夕


访客:366

离线:6天前



夏陌夕
17天前

集合一次性添加多个元素

微信图片_20200617192527.png



分享 数据结构

夏陌夕
17天前

  • 特点是:先进后出
    微信图片_20200617101001.png

队列

  • 特点是:先进先出

数组

  • 特点是:查询快,增删慢
    微信图片_20200617101033.png

链表

  • 特点是:查询慢,增删快
    微信图片_20200617101042.png

红黑树

  • 特点是:查询非常快
  • 微信图片_20200617101047.png


分享 有趣的Java

夏陌夕
18天前

斗地主小游戏

微信图片_20200616235035.png

package DouDiZhu;

import java.util.ArrayList;
import java.util.Collections;

/*
* 斗地主案例:
*   1、准备牌
*   2、洗牌
*   3、发牌
*   4、看牌
* */
public class demoDouDiZHu {
    public static void main(String[] args) {
    /*
        1、准备牌

    */

//      定义一个存储54张牌的集合ArrayList,泛型使用String数据类型
        ArrayList<String> poker = new ArrayList<>();
//        定义两个数组,一个用来存储牌的花色,一个用来存储牌的序号
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
//        先将大王和小王存储poker集合中
        poker.add("大王");
        poker.add("小王");
//        循环嵌套两个数组,组装成52张牌(使用增强for循环)
        for (String number : numbers){
            for (String color : colors) {
//                System.out.println(color + number);
                poker.add(color + number);
            }
        }
//        System.out.println(poker);

        /*
        * 2、洗牌
        *   可以使用集合的工具类Collections中的方法
        *       static void shuffle(list <?> list)使用默认随机源对指定列表进行置换
        * */
        Collections.shuffle(poker);
//        System.out.println(poker);

        /*
        3、发牌
        */
//        定义4个集合存储玩家的牌和底牌
        ArrayList<String> player01 = new ArrayList<>();
        ArrayList<String> player02 = new ArrayList<>();
        ArrayList<String> player03 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();

        /*
        * 遍历poker集合,获取每一张牌
        * 使用poker集合的索引%3给3个玩家轮流发牌
        * 剩余3张牌给底牌
        *   注意:
        *   1、先判断底牌(i>=51),否则牌就没了
        * */
        for (int i = 0; i <poker.size() ; i++) {
            //获取每一张牌
            String p = poker.get(i);
            //轮流发牌
            if (i >= 51){
                //给底牌发牌
                dipai.add(p);
            }else if (i % 3 == 0){
                //给玩家1发牌
                player01.add(p);
            }else if (i % 3 == 1){
                //给玩家2发牌
                player02.add(p);
            }else if (i % 3 == 2){
                //给玩家3发牌
                player03.add(p);

            }
        }
        /*
            4、看牌
        * */
        System.out.println("刘德华" + player01);
        System.out.println("周润发" + player02);
        System.out.println("周星驰" + player03);
        System.out.println("底牌" + dipai);
    }
}

计算一个字符串中字符出现的次数

微信图片_20200617191714.png

package test4Map;

import java.util.HashMap;
import java.util.Scanner;
/*
    练习:
        计算一个字符串中每个字符出现次数
    分析:
        1、使用Scanner获取用户输入的字符串
        2、创建Map集合。其中key是字符串中的字符,value是字符个数
        3、遍历字符串,获取每一个字符
        4、使用获取到的每一个字符,去Map集合判断key是否存在
                key存在:
                    通过字符(key),获取value(字符个数)
                    value++
                    put(key,value)把新的value存储到Map集合中
                key不存在:
                    put(key,1)
         5、遍历Map集合,输出结果
     */
public class demoMapTest {
        public static void main(String[] args) {
//          1、使用Scanner获取用户输入的字符串
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串:");
            String str = sc.next();
//          2、创建Map集合。其中key是字符串中的字符,value是字符个数
            HashMap<Character,Integer> map = new HashMap<>();
//          3、遍历字符串,获取每一个字符
            //使用增强for循环遍历
            for (char c : str.toCharArray()) {
//                 4、使用获取到的每一个字符,去Map集合判断key是否存在
                if (map.containsKey(c)){
                    //key存在
                    Integer value = map.get(c);
                        value++;
                        map.put(c,value);
                }else{
                    //key不存在
                    map.put(c,1);
                }
            }
//           5、遍历Map集合,输出结果
            //使用增强for循环遍历集合
            for (Character key : map.keySet()) {
                Integer value = map.get(key);
                System.out.println(key + "--->" + value);
            }
        }
}



分享 java基础

夏陌夕
1个月前

print、printf和println的区别

  • ASCII码转字符
package demo3;
public class demo3print {
    public static void main(String[] args){
        System.out.print((char)73);
        System.out.print((char)32);
        System.out.print((char)99);
        System.out.print((char)97);
        System.out.print((char)110);
        System.out.print((char)32);
        System.out.print((char)100);
        System.out.print((char)111);
        System.out.print((char)32);
        System.out.print((char)105);
        System.out.print((char)116);
        System.out.print((char)33);
    }
}
/*printf主要是继承了C语言的printf的一些2113特性,可以进行格式化输出
  print就是一般的标准输出,但是不换行5261
  println和print基本没什么差别,就是最后会换行
        System.out.printf("the number is: %12d",t);
        参照JAVA API的定义如下:
        'd' 整数 结果4102被格式化为十进制1653整数
        'o' 整数 结果被格式化为八进制整数
        'x', 'X' 整数 结果被格式化为十六进版制整数
        'e', 'E' 浮点 结果被格式化为用计算机科学记数法表示的十进制数
        'f' 浮点 结果被格式化为十进制数
        'g', 'G' 浮点 根据精度和舍入运算后的值,使用计算机科学记数形式或十权进制格式对结果进行格式化。
        'a', 'A' 浮点 结果被格式化为带有效位数和指数的十六进制浮点数
        println("test")相当于print("test\n")就是一般的输出字符串
*/


java中的进制转换

1、十六进制转换为十进制并控制域宽


public class fenerzhizi {
    public static void main(String[] args){
        String str="ABCDEF";
        /*parseInt(String s,int radix)的目的是输出一个十进制数,
        这个数字是“String s”但是我们要知道他是多少进制的,
        而方法中“int radix”参数正是来表达这个信息的。
         */
        //%md 是用来控制域宽的,15位域宽就写作 %15d;
        System.out.printf("%15d",Integer.parseInt(str,16));
    }
}


2、 十进制转换为八进制和十六进制

/*
* 将十进制1234转换为八进制和十六进制。
* */
public class fenerzhizi {
    public static void main(String[] args){
        int num=1234;
        System.out.print("0"+Integer.toOctalString(num)+" ");
        String shiLiu=Integer.toHexString(num);
        System.out.println("0X"+shiLiu.toUpperCase());
    }
}
package demo5;

import java.util.Scanner;

public class demo5Switch {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            String str1=sc.next();
            String str2=sc.next();

            String num1=str1.substring(2,str1.length());
            String num2=str2.substring(1,str2.length());
                // Integer.valueOf(s)在Integer.parseInt(s)的计算的基础上,将int类型的数值转换成了Integer类型,
                // 这样转换的意义大家也应该都知道,就是基本类型的包装类型是引用类型。
                // 所以单单为了为了得到一个int值,就用Integer.parseInt(s)就行了。
                // 如果为了得到包装类型就用Integer.valueOf(s)。毕竟缓存了一部分数值,可以加强点儿性能。
            int a=Integer.valueOf(num1,16);
            int b=Integer.valueOf(num2,8);
            System.out.println(a+b);
        }
    }
}

package demo6;
import java.util.Scanner;
public class demo6Exchange {
    public static void main(String [] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str=sc.next();
            if(str.matches("[A-Z]")){
                //str.toLowerCase()表示转换为小写字母;
                System.out.println(str.toLowerCase());
            }
            else
                {
                    //str.toUpperCase()表示转换为大写字母;
                    System.out.println(str.toUpperCase());

                }
            }
        }
}


字符转ASCII码

package demo3;

import java.util.Scanner;
//char类型自动转换为int类型
public class demo3print {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            String s =sc.next();
            char ss = s.charAt(0);
            //stringObject.charAt(index),charAt() 方法可返回指定位置的字符。
            int result = ss;
            System.out.println(result);
        }
    }
}

Scanner的用法

import java.util.Arrays;
import java.util.Scanner;

public class demo1scanner {
    Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        System.out.println("输入:");
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        int[] num1 = new int[m];
        int[] num2 = new int[n];
        // 换成其他数据类型也一样,其他数值类型就修改int跟nextInt就可以了,
        //String就把nextInt()换成next()
        for(int i = 0; i < m; i ++) {
            num1[i] = sc.nextInt();  // 一个一个读取
        }
        for(int i = 0; i < n; i ++) {
            num2[i] = sc.nextInt();
        }
        System.out.println("输出:");
        System.out.println(Arrays.toString(num1));
        System.out.println(Arrays.toString(num2));
    }
}

1、 Scanner和Random随机数的小游戏

package demo1;
/*猜数字的小游戏
1、产生一个随机数;三步骤
   1)、导包;import java.util.Random;
   2)、创建;Random r = new Random();
   3)、使用;
          获取一个随机数字(范围是int所有范围,由正负两种):int num = r.nextInt();
          获取一个随机数字(参数代表了范围,左闭右开区间):int num = r.nextInt(3);表示[0,3)区间,也就是0~2;
2、键盘输入;三步骤
   1)、导包;import java.util.Random;
   2)、创建;Scanner sc = new Scanner(System.in);
   3)、使用;int num = sc.nextInt();
            String str = sc.next();
3、得到两个数字,if判断一下;
     如果太大了,提示太大,请重试;
     如果太小了,提示太小,请重试;
     如果猜中了,结束游戏。
4、重试就是再来一次,循环次数不确定,用while(true);
* */
import java.util.Random;
import java.util.Scanner;

public class demoRandom1 {
    public  static void main(String[] args){
        Random r = new Random();//产生一个随机数
        int randomNum = r.nextInt(100) + 1;//随机数在[1,100]的范围中。
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请输入你猜测的数字:");
            int guessNum = sc.nextInt();//Scanner的使用。
            if (guessNum < randomNum){
                System.out.println("太小了,请重试!");
            }
            else if (guessNum > randomNum) {
                System.out.println("太大了,请重试!");
            }
            else{
                System.out.println("恭喜你,猜中了!");
                break;//如果猜中,就不再重试。
            }
        }
        System.out.println("游戏结束");
    }
}

自定义类的步骤:4个组成部分

1、 自定义类

package demo2;
//自定义一个标准的person类:4个组成部分
public class person {
    private String name;
    private int age;

/*1、所有成员变量都要使用private关键字修饰;
  2、ALT + INSERT快捷键  或者 Code+Generate+Constructor为每一个成员变量一个无参数的构造方法;
  3、ALT + INSERT快捷键  或者 Code+Generate+Constructor为每一个成员变量一个全参数的构造方法;
  4、为每一个成员变量编写一对Getter/Setter方法。
  */
    public person() {
    }

    public person(String name, int age) {
        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;
    }
}

2、 使用自定义类

package demo2;
/*题目:
定义一个数组,用来存储3个person对象。
数组有一个缺点:数组一旦创建,其长度不可改变。*/
public class demo2Array {
    public static void main(String[] args){
        person[] array = new person[3];//创建一个长度为3的数组,用来存放person类型的对象;
        person one = new person("古力娜扎",18);
        person two = new person("迪丽热巴",28);
        person three = new person("马尔扎哈",38);

        //将one当中的地址值赋值到数组的0号元素位置;
        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]);//地址值
        System.out.println(array[1]);//地址值
        System.out.println(array[2]);//地址值

        System.out.println(array[1].getName());//迪丽热巴
    }
}

  • 移位运算
/*二、移位运算

  下面介绍三种移位运算,

  首先我们对5作运算。

  5在内存中的存储形式为:0000 0000 0000 0000 0000 0000 0000 0101

  1、左移<<

   符号位会被保留,数值位左移一位,低位补0,变为:

   0000 0000 0000 0000 0000 0000 0000 1010

   得到值为10

  2、右移>>

   符号位会被保留,数值位左移一位,数值位高位补0,变为:

   0000 0000 0000 0000 0000 0000 0000 0010

   得到值为2

  可以看到,左移相当于乘以2,右移相当于除以2,JDK中很多源码都采用了这种写法,效率高而且优雅

  3、无符号右移>>>

   >>>在右移时会将符号位当做数值位处理,一起右移,高位补0

   为了清楚地演示出符号位的变化,以-5为例:

   -5在内存中的存储形式为:1111 1111 1111 1111 1111 1111 1111 1011

   >>>1      后得到:   0111 1111 1111 1111 1111 1111 1111 1101*/

根据字符个数,动态输入占位符

package demo7;
import java.util.Collections;
import java.util.Scanner;
public class demo7TuAn {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()){
            int times = sc.nextInt();
            System.out.println(String.join("", Collections.nCopies(times,"*")));
            }
        }
}
/*System.out.println(String.join(",", Collections.nCopies(10,"8")));
                        输出结果为:8,8,8,8,8,8,8,8,8,8
                        根据字段个数,动态生成sql的占位符,*/

ArrayList的常用方法

  • 特点是:查询快,增删慢
import java.util.ArrayList;
import java.util.Random;
public class demo8ArrayList {
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<>();//创建一个集合
        Random r = new Random();//产生随机数
        for (int i = 0; i < 6; i++) {
            int num = r.nextInt(33) + 1;
            list.add(num);//将数据添加到集合中
        }
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}


LinkedList集合常用方法

  • 特点是:查询慢,增删快
package test3;

import java.util.LinkedList;

/*java.util.LinkedList集合 implements List接口
*       LinkedList集合的特点:
*           1、底层是一个链表结构:查询慢,增删快。
*           2、里边包含了大量操作首尾元素的方法
*       注意:使用LinkedList集合中的方法,不能使用多态
*
*       public void addFirst(E e):将指定元素插入此列表的开头
*       public void addLast(E e):将指定元素插入此列表的末尾
*       public void push(E e):将元素推入此列表所表示堆栈,等效于addFirst()方法
*
*       public E getFirst():返回此列表的第一个元素
*       public E getLast():返回此列表的最后一个元素
*
*       public E removeFirst():移除并返回此列表的第一个元素
*       public E removeLast():移除并返回此列表的最后一个元素
*       public E pop():从此列表所表示的堆栈处弹出一个元素
*
*       public boolean isEmpty():如果此列表不包含此元素,则返回true
* */
public class demoLinkedList {
    public static void main(String[] args) {
        show01();
        show02();
        show03();
    }
    /*public E removeFirst():移除并返回此列表的第一个元素
    * public E removeLast():移除并返回此列表的最后一个元素
    * public E pop():从此列表所表示的堆栈处弹出一个元素,此方法等效于removeFirst();
    * */
    private static void show03() {
        //创建LinkedList集合
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);//[a, b, c]

//      public E removeFirst():移除并返回此列表的第一个元素
        linked.removeFirst();
        System.out.println(linked); //[b, c]

//      public E pop():从此列表所表示的堆栈处弹出一个元素,此方法等效于removeFirst()
        String p = linked.pop();
        System.out.println("返回值是:" + p); //返回值是:b


//      public E removeLast():移除并返回此列表的最后一个元素
        linked.removeLast();
        System.out.println(linked); //[]
    }

    private static void show02() {
        //创建LinkedList集合
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);//[a, b, c]

//        linked.clear();//清空集合中的元素,在获取元素时会出现NoSuchElementException异常

//        public boolean isEmpty():如果此列表不包含此元素,则返回true
        if (!linked.isEmpty()){
            String first = linked.getFirst();
            System.out.println("第一个元素:" + first);//第一个元素:a
            String last = linked.getLast();
            System.out.println("最后一个元素:" + last);//最后一个元素:c
        }

    }

    /*public void addFirst(E e):将指定元素插入此列表的开头
     *public void addLast(E e):将指定元素插入此列表的末尾
     *public void push(E e):将元素推入此列表所表示堆栈
     * */

    private static void show01() {
        //创建LinkedList集合
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);//[a, b, c]

        //public void addFirst(E e):将指定元素插入此列表的开头
        linked.addFirst("www");
        //linked.push("www"); //等效于linked.addFirst("www")
        System.out.println(linked);//[www, a, b, c]

        //public void addLast(E e):将指定元素插入此列表的末尾,等效于add()
        linked.addLast("com");
        System.out.println(linked);//[www, a, b, c, com]


    }
}

使用增强for循环遍历集合或数组

package test3;
/*
    增强for循环:用来遍历集合和数组
 格式:
*   for(集合/数组的数据类型 变量名 :集合名/数组名){
        System.out.println(变量名)
        }
*
* */

public class Foreach {
    public static void main(String[] args) {
        demo01();
    }

//使用增强for循环遍历集合
    private static void demo01() {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i : arr){
            System.out.println(i);
        }

    }
}

集合的父接口Collection

package test3;

import java.util.ArrayList;
import java.util.Collection;
/*Collection是所有单列集合的父接口
*   1、add(E e):把指定的元素添加到当前集合中
*   2、clear():清空集合
*   3、remove(E e):把给定的对象在当前集合中删除
*   4、contains(E e):判断当前集合中是否包含给定的对象
*   5、isEmpty():判断当前集合是否为空
*   6、size():返回集合元素的个数
*   7、public Object[] toArray():把集合中的元素,存储到数组中
* */
public class Colllection {
    public static void main(String[] args) {
//        创建集合对象,使用多态
        Collection<String> coll = new ArrayList<>();//接口指向实现类
        coll.add("张三");//返回值是布尔值,一般都是True,所以可以不用接收
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);//重写了toString方法

/*remove()方法:返回值是布尔值,删除集合中存在元素,返回值为true
                           删除集合中不存在元素,返回值为false;*/

        boolean b1 = coll.remove("赵六");
        System.out.println("b1:" + b1);//b1:true

        boolean b2 = coll.remove("赵四");
        System.out.println("b2:" + b2);//b2:false

//        contains()方法
        boolean b3 =coll.contains("李四");
        System.out.println("b3:" + b3);//b3:true

        boolean b4 =coll.contains("赵四");
        System.out.println("b4:" + b4);// b4:false

//        isEmpty():判断集合是否为空,集合为空,返回true;
                                //集合不为空,返回false;
        boolean b5 =coll.isEmpty();
        System.out.println("b5:" + b5);//b5:false

        int size = coll.size();
        System.out.println("size:" + size);//size:4

//        public Object[] toArray():把集合中的元素,存储到数组中
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

//        clear();清空集合,但不是删除集合,集合还存在
         coll.clear();
        System.out.println(coll);
    }
}

Collections

  • Collections的一般使用方法

import java.util.ArrayList;
import java.util.Collections;

/*
    Collections的一些常用方法:
        1、Collections.addAll(Collections<T> c, T...elements):往集合中添加元素
        2、public static void shuffle(list<?> list):打乱顺序,打乱集合顺序
        3、public static <T> void sort(list<?> list):将集合这种元素按照默认规则排序
    注意:
        sort(list<?> list)使用前提
            该排序的集合里面存储的元素,必须实现Comparable,重写接口中的方法comparableTo定义排序的规则

    Comparable接口排序规则:
        自己(this)-参数:升序排列
        参数- 自己(this):降序排列
*/
public class demoCollections {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList<String> list1 = new ArrayList<>();

        list1.add("c");
        list1.add("a");
        list1.add("b");
        System.out.println(list1);//[c, a, b]

//      public static <T> void sort(list<?> list):将集合这种元素按照默认规则(升序)排序
        Collections.sort(list1);
        System.out.println(list1);//[a, b, c]

        // Collections.addAll(Collections<T> c, T...elements):往集合中添加元素
        Collections.addAll(list,"a","b","c","d");
        System.out.println(list); //[a, b, c, d]

        //public static void shuffle(list<?> list):打乱顺序,打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list); //[b, d, c, a]


    }
}

  • Collections的sort排序(加入比较器comparator)
package test3JiHe;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class demoCollectionsStudent {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student(18, "Y杨幂"));
        list.add(new Student(20, "迪丽热巴"));
        list.add(new Student(17, "杨幂"));
        list.add(new Student(18, "G古力娜扎"));
        System.out.println(list);

        /*Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
//                按照年龄升序排列
                return o1.getAge() - o2.getAge();
//                按照年龄降序排列
//                return o1.getAge() - o2.getAge();
            }
        });*/

        Collections.sort(list, new Comparator<Student>() {
            //重写比较的规则
            @Override
            public int compare(Student o1, Student o2) {
//               按照年龄升序排列
               int  result = o1.getAge() - o2.getAge();
//               如果两个人年龄相同,则按照姓名的首字母排序
                if (result == 0){
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
             }
        });
        System.out.println(list);
    }
}

迭代器Iterator

package test3;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;


/*java.util,Iterator接口;迭代器(对集合进行遍历)
    Iterator迭代器:即Collection集合元素的通用获取方式
        在取之前,先判断集合中有不有元素,如果有,就把这个元素取出来,继续再判断,如果还有就继续取出,
        直到把集合中的元素全部取出来。这种方式专业术语称为迭代。
     Iterator接口的常用方法:
        1、public E next():返回迭代的下一个元素
        2、public boolean hasNext():如果仍有元素,则返回true。
    Iterator<E> iterator()方法在此collection的元素上进行迭代的迭代器

    迭代器的使用步骤:
        1、先使用集合中的方法iterator()来获取迭代器的实现类对象,使用Iterator接口接收(多态)
        2、使用Iterator接口中的方法hasNext判断有没有下一个元素
        3、使用Iterator接口中的方法next取出集合中的下一个元素
*/
public class demoIterator {
    public static void main(String[] args) {
//        创建一个集合对象
        Collection<String> coll = new ArrayList<>();
//        往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");

//       Iterator<E>迭代器也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型
//        多态   接口           实现类对象
        Iterator<String> it =  coll.iterator();

//        while循环
        while(it.hasNext()){
            String e = it.next();
            System.out.println(e);
        }
        System.out.println("---------------");

//        for循环
        for (Iterator<String> it2 = coll.iterator(); it2.hasNext();){
            String e1 = it2.next();
            System.out.println(e1);
        }
//        boolean b = it.hasNext();
//        System.out.println(b);
//        String s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);
//        s = it.next();
//        System.out.println(s);
//
//        b = it.hasNext();
//        System.out.println(b);//没有元素,返回false
//        s = it.next();//NoSuchElementException没有元素异常
//        System.out.println(s);
    }
}

List接口

package test3;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
* Java.util.List接口extends Collection接口
*   List接口的特点:
*       1、有序的集合,存储元素和取出元素的顺序是一致的
*       2、有索引,包含一些带索引的方法
*       3、允许储存重复的元素
*   List接口带索引的方法(特有):
*       1、public void add(int index, E element):将指定的元素,添加到该集合指定的位置上
*       2、public E get(int index):返回集合中指定位置的元素
*       3、public E remove(int index):移除列表中指定位置的元素,返回的是被移除的元素
*       4、public E set(int index,E element):用指定元素替换集合指定位置的元素,返回值是更新前的元素
*   注意:
*       操作索引的时候,一定要防止索引越界。
* */
public class demoList {
    public static void main(String[] args) {
        //创建一个List集合,可以使用多态
        List<String> list = new ArrayList<>();
        //使用add方法添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        //打印集合
        System.out.println(list);

//        public void add(int index, E element):将指定的元素,添加到该集合指定的位置上
//        在c与d之间,添加一个元素“idHeiMa”
        list.add(3,"idHeiMa");
        System.out.println(list);

//        public E remove(int index):移除列表中指定位置的元素,返回的是被移除的元素
//        移除C元素
//        list.remove("c");
        String removeE = list.remove(2);
        System.out.println("被移除的元素:" + removeE); //被移除的元素:c
        System.out.println(list); //[a, b, idHeiMa, d, a]

//      public E set(int index,E element):用指定元素替换集合指定位置的元素,返回值是更新前的元素
//      把最后一个a替换成为A
        String setE = list.set(4, "A");
        System.out.println("被替换的元素:" + setE); // 被替换的元素:a
        System.out.println(list); //[a, b, idHeiMa, d, A]

//        List集合遍历有三种方式
            //1、使用普通的for循环
        for (int i = 0; i < list.size(); i++) {
//        public E get(int index):返回集合中指定位置的元素
            String getE = list.get(i);
            System.out.println(getE);
        }
        System.out.println("-------------");
            //2、使用迭代器遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String n = it.next();
            System.out.println(n);
        }
        System.out.println("--------------");
            //3、使用增强for循环
        for (String i : list) {
            System.out.println(i);
        }
    }
}

Set接口

  • HashSet集合
package test3JiHe;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
    java.util.HashSet集合 implements Set 接口
*   HashSet 的特点:
*       1、不允许存储重复的元素
*       2、没有索引,没有带索引的方法,也不能使用普通的for循环遍历
*       3、是一个无序的集合,存储元素和取出元素的顺序可能不一致
*       4、底层是一个哈希表结构(查询的速度非常快)
* *
* */
public class demoHashSet {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        //使用add方法往集合中添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);

//        使用迭代器遍历集合
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            Integer n = it.next();
            System.out.println(n);//1,2,3

            System.out.println("---------------");
//         使用增强for循环遍历
            for (Integer i :set) {
                System.out.println(i);
            }
        }
    }
}

哈希表的数据结构

微信图片_20200617151347.png
- 哈希值hashCode

package test3JiHe;
/*
* 哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,
*       是模拟出来得到地址,不是数据实际存储的物理地址)
*       在Object类中的有一个方法,可以获取对象的哈希值
*                   int hashCode() 返回对象的哈希码值。
        hashCode的源码:
                public native int hashCode();
                native:代表该方法调用的是本地操作系统的方法
 */

import demo2.Person;

public class hashCode {
    public static void main(String[] args) {
        Person p = new Person();
        int h = p.hashCode();
        System.out.println(h); //189568618,十进制的整数

        Person p1 = new Person();
        int h1 = p1.hashCode();
        System.out.println(h1); //793589513,十进制的整数

        /*
        * toString方法的源码:
        *       return getClass().getName() + "@" + Integer.toHexString(hashCode());
        * */

        System.out.println(p); //demo2.Person@b4c966a,十六进制的地址值
        System.out.println(p1); //demo2.Person@2f4d3709,十六进制的地址值

        /*字符串String类的哈希值
        *   String类重写了Object类的hashCode方法*/

        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode()); //96354
        System.out.println(s2.hashCode()); //96354

//        特殊:两个字符串不一样,但是哈希值是一样的
        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
    }
}

Map集合

  • Map集合的常用方法
    微信图片_20200617180848.png
import java.util.HashMap;
import java.util.Map;

public class demoMap {
    public static void main(String[] args) {
        show01();
        show02();
        show03();
        show04();
    }
    /*
        boolean containsKey(Object key):判断集合中是否包含指定的键
            包含返回true,不包含返回false
    */
    private static void show04() {
        //        创建一个Map3集合
        Map<String,Integer> map3 = new HashMap<>();
        map3.put("赵丽颖",168);
        map3.put("杨颖",165);
        map3.put("林志玲",178);

        boolean b1 = map3.containsKey("赵丽颖");
        System.out.println("b1:" + b1); //b1:true

        boolean b2 = map3.containsKey("赵颖");
        System.out.println("b2:" + b2); //b2:false


    }

    /*
        public V get(Object key):根据指定的键,在Map集合中获取对应的值
           返回值:v
                k存在,返回对应的value值
                k不存在,返回null
     */
    private static void show03() {
//        创建一个Map2集合
        Map<String,Integer> map2 = new HashMap<>();
        map2.put("赵丽颖",168);
        map2.put("杨颖",165);
        map2.put("林志玲",178);

        Integer v1 = map2.get("杨颖");
        System.out.println("v1:" + v1); //v1:165

        Integer v2 = map2.get("林志颖");
        System.out.println("v2:" + v2); //v2:null

    }

    /*
        public V remove(Object key):把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的值
            返回值:v
                k存在,v返回被删除元素的值
                k不存在,v返回值为null
    */
    private static void show02() {
//        创建一个Map1集合
        Map<String,Integer> map1 = new HashMap<>();
        map1.put("赵丽颖",168);
        map1.put("杨颖",165);
        map1.put("林志玲",178);
        System.out.println(map1);

//        使用remove()方法删除元素
        Integer v1 = map1.remove("林志玲");
        System.out.println("v1:" + v1); //v1:178

        System.out.println(map1); //{赵丽颖=168, 杨颖=165}

        Integer v2 = map1.remove("林志颖");
        System.out.println("v2:" + v2); //v2:null
    }

    /*
        public V put(K key,V value):把指定的键与值添加到指定的Map集合中
            返回值:v
                存储键值对的时候,k不重复,返回值是null
                存储键值对的时候,k重复,会使用新的value替换Map集合中重复的value,返回被替换的value
     */
    private static void show01() {
//        创建Map集合,可以使用多态
        Map<String,String> map = new HashMap<>();
//        使用put往集合中添加元素
        String v1 = map.put("李晨", "范冰冰1");
        System.out.println("v1:" + v1);//v1:null

        String v2 = map.put("李晨", "范冰冰2");
        System.out.println("v2:" + v2);//v2:范冰冰1
        System.out.println(map); //{李晨=范冰冰2}

        map.put("冷锋","龙小云");
        map.put("杨过","小龙女");
        map.put("尹志平","小龙女");
        System.out.println(map);
    }
}

  • Map集合的第一种遍历方式:keySet()
    微信图片_20200617180858.png
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
        遍历Map集合的第一种方式:keySet()通过键找值的方法
        Map集合中的方法:
                Set<K> keySet():返回此映射中包含的键的Set视图
        实现步骤:
            1、使用Map集合中的方法keySet(),把每一个Key取出来。存储到一个Set集合中去
            2、遍历Set集合,获取Map集合中的每一个Key
            3、通过Map集合中的方法get(Key),通过key找到value
     */
public class demoKeySet {
        public static void main(String[] args) {
//            创建一个Map1集合
            Map<String,Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);

            //1、使用Map集合中的方法keySet(),把每一个Key取出来。存储到一个Set集合中去
            Set<String> set = map.keySet();

            // 2、遍历Set集合,获取Map集合中的每一个Key
//            使用迭代器遍历Set集合
            Iterator<String> it = set.iterator();
            while(it.hasNext()) {
                String key = it.next();
                //3、通过Map集合中的方法get(Key),通过key找到value
                Integer value = map.get(key);
                System.out.println(key + "=" + value);
            }

            System.out.println("-------------");
//            使用增强for循环遍历Set集合
            for (String key : map.keySet()){
                //3、通过Map集合中的方法get(Key),通过key找到value
                Integer value = map.get(key);
                System.out.println(key + "=" + value);
            }
        }
}

  • Map集合的第二种遍历方式:entrySet()
    微信图片_20200617180902.png
package test4Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
    遍历Map集合的第二种方式:entrySet()通过键找值的方法
        Map集合中的方法:
                Set<Map.entrySet<K,V>> entrySet():返回此映射中包含的键的Set视图
        实现步骤:
            1、使用Map集合中的方法entrySet(),把Map集合中的多个Entry对象取出来。存储到一个Set集合中
            2、遍历Set集合,获取每一个Entry对象
            3、使用Entry对象中的方法getKey()和getValue()获取键与值
     */
public class demoEntrySet {
        public static void main(String[] args) {
//            创建一个Map1集合
            Map<String,Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);

//            1、使用Map集合中的方法entrySet(),把Map集合中的多个Entry对象取出来。存储到一个Set集合中
            Set<Map.Entry<String, Integer>> set = map.entrySet();
//            2、遍历Set集合,获取每一个Entry对象
            //使用迭代器遍历Set集合
            Iterator<Map.Entry<String, Integer>> it = set.iterator();
            while(it.hasNext()){
                Map.Entry<String, Integer> entry = it.next();
//                3、使用Entry对象中的方法getKey()和getValue()获取键与值
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key + "=" + value);
            }
            System.out.println("---------------");
            //使用增强for循环遍历Set集合
            for (Map.Entry<String,Integer> entry:set){
//                3、使用Entry对象中的方法getKey()和getValue()获取键与值
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key + "=" + value);
            }
        }
}

HashMap存储自定义类型键值

package test4Map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
    HashMap存储自定义类型键值
    Map集合保证key是唯一的;
        作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一
     */
public class demoTest {
    public static void main(String[] args) {
        show01();
        show02();
    }
    /*
        HashMap存储自定义类型键值
            key:Person类型
                Person类必须重写hashCode方法和equals方法,以保证key唯一。
            value:String类型
                可以重复。(同名同年龄的人视为同一个)
     */
    private static void show02() {
        //创建一个HashMap集合
        HashMap<Person,String> map = new HashMap<>();
        //往集合中添加元素
        map.put(new Person("女王",18),"英国");
        map.put(new Person("秦始皇",18),"秦朝");
        map.put(new Person("普京",30),"俄罗斯");
        map.put(new Person("女王",18),"毛里求斯");

        //使用EntrySet()和增强for循环遍历集合
        Set<Map.Entry<Person, String>> set = map.entrySet();
        for (Map.Entry<Person, String> entry : set) {
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "--->" + value);
        }
    }

    /*
        HashMap存储自定义类型键值
            key:String类型
                String类重写了hashCode方法和equals方法,可以保证key唯一
            value:Person类型
                value可以重复(同名同年龄的人视为同一个)
    */
    private static void show01() {
        //创建HashMap集合
        HashMap<String,Person> map = new HashMap<>();
        //往集合中添加元素
        map.put("北京",new Person("张三",18));
        map.put("上海",new Person("李四",19));
        map.put("广州",new Person("王五",20));
        map.put("北京",new Person("赵六",18));
        //使用keySet()方法加增强for循环遍历集合
        Set<String> set = map.keySet();
        for (String key : set) {
            Person value = map.get(key);
            System.out.println(key + "--->" + value);
        }
    }
}

ArrayList的几个举例

  • 1、生成6个1~33的随机整数,添加到集合中去并遍历集合。
package demo9;

import java.util.ArrayList;
import java.util.Random;
/*题目
* 生成6个1~33的随机整数,添加到集合中去并遍历集合。
* 思路:
* 1、创建一个集合,用来存储6个数字 <Integer>;
* 2、产生随机数,需要用到 Random;
* 3、循环6次,产生6个随机数字。用到for循环;
* 4、循环内调用r.nextInt(int n),参数是33,集合为0~32,需要整体+1;
* 5、添加到集合,list.add;
* 6、遍历集合:for\size\get*/
public class demo9ArrayList {
    public static void main(String[] args){
        ArrayList<Integer> list = new ArrayList<>();//创建一个集合
        Random r = new Random();//产生随机数
        for (int i = 0; i < 6; i++) {
            int num = r.nextInt(33) + 1;
            list.add(num);//将数据添加到集合中
        }
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

  • 2、自定义4个学生对象,添加到集合并遍历集合。
package demo9;
/*题目:
自定义4个学生对象,添加到集合并遍历集合。

思路:
1、自定义一个学生类。Student,一个标准类包含4部分;
2、创建一个集合,用来存储4个学生对象;
3、根据类,创建4个学生对象;
4、添加到集合,Lsit.add;
5、遍历集合,for\size\get;*/

import java.util.ArrayList;
public class demo9Student {
    public static void main(String[] args){
        ArrayList<Student> list = new ArrayList<>();

        Student one = new Student("欧阳锋",20);
        Student two = new Student("洪七公",21);
        Student three = new Student("黄药师",22);
        Student four = new Student("段智兴",23);

        list.add(one);
        list.add(two);
        list.add(three);
        list.add(four);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println("姓名:" + stu.getName() + ";" + "年龄:" + stu.getAge());
        }
    }
}

  • 3、定义以指定格式打印集合的方法(ArrayLis为参数),使用{}扩起集合,并用@分隔每个元素。
package demo9;
import java.util.ArrayList;
/*题目:
    定义以指定格式打印集合的方法(ArrayLis为参数),使用{}扩起集合,并用@分隔每个元素。
  格式样例:
  System.out,println(list);  //[10, 20, 30]
  printArrayList(list); //{10@20@30}
  思路:
  定义方法的三要素
    1、返回值类型:只是进行打印,没有运算,没有结果,所以用void;
    2、方法名称:printArrayList;
    3、参数列表:ArrayList;
* */
public class demo9ArrayList1 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        //添加字符串到集合中
        list.add("张三丰");
        list.add("张翠山");
        list.add("宋远桥");
        list.add("张无忌");
        //一般打印时
        System.out.println(list); //[张三丰, 张翠山, 宋远桥, 张无忌]

        //调用方法
        printArrayList(list);
    }
        public static void printArrayList(ArrayList<String> list){
//拼接左括号
            System.out.print("{");
            //遍历集合
            for (int i = 0; i < list.size(); i++) {
                //获取元素
                String name = list.get(i);
                if (i == list.size() - 1){
                    System.out.print(name + "}");
                }else {
                    System.out.print(name + "@");
                }
            }
        }
}

  • 4、用一个大集合存入20个随机数字,然后筛选其中的偶数元素,放到小集合中;
package demo9;

import java.util.ArrayList;
import java.util.Random;

/*
* 题目
*   用一个大集合存入20个随机数字,然后筛选其中的偶数元素,放到小集合中;
* 要求:使用自定义的方法实现筛选。
*
* 分析:
*   1、需要一个大集合,用来存储int数字<Integer>;
*   2、随机数字,Random nextInt;
*   3、循环20次,把随机数放到大集合中(for循环,add方法);
*   4、自定义一个方法,用来进行筛选;
* 自定义方法三要素:
*   1、返回值类型:ArrayList小集合(里面元素不确定);
*   2、方法名称:getSmallList
*   3、参数列表:ArrayList大集合(装着20个随机数字);*/
public class demo9ArrayList2 {
    public static void main(String[] args) {
        //创建一个大集合;
        ArrayList<Integer> bigList = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;//[1~100]
            bigList.add(num);
        }
        ArrayList<Integer> smallList = getSmallList(bigList);//调用方法
        for (int i = 0; i < smallList.size(); i++) {
            System.out.println(smallList.get(i));//遍历集合
        }
        System.out.println("偶数个数为:" + smallList.size());//输出集合长度
    }

        //这个方法用来接收大集合,返回小集合结果;
public static ArrayList<Integer> getSmallList (ArrayList<Integer> bigList) {
    //创建一个小集合,用来存储偶数结果;
    ArrayList<Integer> smallList = new ArrayList<>();
    for (int i = 0; i < bigList.size(); i++) {
        int num = bigList.get(i);
        if (num % 2 == 0) {
            smallList.add(num);
        }
    }
    return smallList;
    }
}

计算一个人已经出生了多少天

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
/*
*   练习:
*       请使用日期与时间的相关API,计算出一个人已经出生了多少天
*   分析:
*       1、使用Scanner类中的next方法,获取出生日期
*       2、使用DateFormat类中的方法parse,把字符串的出生日期,解析成为Date格式的出生日期
*       3、把Date格式的出生日期转换为毫秒值
*       4、获取当前的日期转换为毫秒值
*       5、使用当前日期的毫秒值—出生日期的毫秒值
*       6、把毫秒值转换为天(s/1000/60/60/24)
* */
public class Main {
    public static void main(String[] args) {
//        1、使用Scanner类中的next方法,获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的出生日期,格式为:yyyy-MM-dd");
        String birthdayDateString = sc.next();

//      2、使用DateFormat类中的方法parse,把字符串的出生日期,解析成为Date格式的出生日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = null;
        try {
            birthdayDate = sdf.parse(birthdayDateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }

//      3、把Date格式的出生日期转换为毫秒值
        long birthDateTime = birthdayDate.getTime();

//      4、获取当前的日期转换为毫秒值
        long todayTime = new Date().getTime();

//      5、使用当前日期的毫秒值—出生日期的毫秒值
        long time = todayTime - birthDateTime;

//      6、把毫秒值转换为天(s/1000/60/60/24)
        System.out.println(time / 1000/60/60/24);

    }
}

System类的ArrayCopy方法

package test2;
import java.util.Arrays;
public class demoArrayCopy {
    public static void main(String[] args) {

//        定义一个源数组

        int[] src = {1,2,3,4,5};

//        定义目标数组

        int[] dest = {6,7,8,9,10};
        System.out.println("复制前:" + Arrays.toString(dest));

//        使用System中的arrayCopy方法把源数组中的钱3个元素复制到目标数组的钱3个位置上

        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后:" + Arrays.toString(dest));
    }
}

Java异常

package test5Throwable;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
        java.lang.Throwable类是Java语言所有错误和异常的超类(父类)
            Exception:编译期异常,进行编译Java程序出现的问题
                RuntimeException:运行期异常,Java程序运行中出现的异常
            Error:错误
        * */
public class demoReception {
    public static void main(String[] args) {
//    Exception:编译期异常,进行编译Java程序出现的问题
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//用来格式化日期
        Date date = null;
        try {
            date = sdf.parse("2000-0905");//把字符串格式日期,解析为date格式日期
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(date);
        System.out.println("后续代码");
    }
}

  • 异常处理原理
    -微信图片_20200618100856.png
  • Object的非空判断
    微信图片_20200618102106.png
  • Java异常的第一种处理方式Throws
    微信图片_20200618143849.png
package test5Throwable;

import org.w3c.dom.ls.LSOutput;

import java.io.FileNotFoundException;

public class demoThrows {
    public static void main(String[] args) throws FileNotFoundException {
        readFile("c:\\a.txt");
    }

    /*定义一个方法,对传递的文件路径进行合法性判断
     *   如果路径不是“c:\\a.txt”,就抛出文件找不到异常,告知方法的调用者
     *       FileNotFoundException是文件编译异常,抛出了编译异常,就必须处理这个异常
     *       可以使用throws,或者使用try...catch;
     * */
    public static void readFile(String fileName) throws FileNotFoundException {
        if (!fileName.equals("c:\\a.txt")) {
            throw new FileNotFoundException("文件找不到");
        }
        System.out.println("路径没有问题,读取文件");
    }
}
  • 异常处理的第二种方式try… Catch
    微信图片_20200618172330.png
  • Finally代码块
    微信图片_20200618173015.png


分享 Java笔记

夏陌夕
1个月前

JAVA笔记

数组

/* 动态初始化,直接指定数组长度,数组元素个数
     格式:数据类型[] 数组名称 = new 数据类型[数组长度];
    静态初始化,在创建数组的时候,不直接指定数组长度,而是直接指定数组的具体内容
     格式:数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,....};*/

import java.util.Scanner;

public class test4 {
    public static void main(String args []) {
        //创建一个数组,里面可以储存300个int数据
        //格式:数据类型[] 数组名称 = new 数据类型[数组长度];
        int[] arrayA = new int[300];
        //创建一个数组,里面可以储存10个double数据
        double[] arrayB = new double[10];
        //创建一个数组,里面可以储存5个string数据
        String[] arrayC = new String[5];

        //创建一个数组,它的具体内容为5,15,25;
        int[] arrayD = new int[]{5,15,25};

        String[] arrayE = new String[]{"Hello","World","Java"};

        //静态创建数组
    double[] myList = {1.9, 2.9, 3.4, 3.5};
    // 打印所有数组元素
        for (int i = 0; i < myList.length; i++) {
        System.out.println(myList[i] + " ");
        }
            // 计算所有元素的总和
        double total = 0;
        for (int i = 0; i < myList.length; i++) {
        total += myList[i];
        }
        System.out.println("Total is " + total);
        // 查找最大元素
        double max = myList[0];
        for (int i = 1; i < myList.length; i++) {
        if (myList[i] > max) max = myList[i];
        }
        System.out.println("Max is " + max);


    }
}

字符串

- [交换任意两个值](https://www.nowcoder.com/practice/95eb723a3e854376a7eb6d116cc7d875?tpId=107&tqId=33296&tPage=1&rp=1&ru=/ta/beginner-programmers&qru=/ta/beginner-programmers/question-ranking)  
import java.util.*;

public class Demochange1 {
        public static void main(String args[]){
            Scanner in = new Scanner(System.in);
            String str = in.next();
            // indexOf 方法可返回某个指定的字符串值在字符串中首次出现的位置。
            int a = str.indexOf('a'); //0
            int b = str.indexOf('b'); //6

            // System.out.println(str.length());
            // 输出字符串的长度,从1开始

            /*
             * substring
             * 方法返回字符串的子字符串
             * beginIndex -- 起始索引(包括), 索引从 0 开始。
             * endIndex -- 结束索引(不包括)
             * */
            String rest1 = str.substring(b + 2,str.length());
            String rest2 = str.substring(a + 2,b - 1);
            System.out.println("a=" + rest1 + ",b=" + rest2);
        }
}
  • 输出浮点数中的一位整数
package demo3;
import java.util.Scanner;
    public class subString{
            public static void main(String[] args){
                Scanner sc = new Scanner(System.in);
                double num=sc.nextDouble();
                String str = String.valueOf(num);
                //按小数点分隔数字字符串
                String[] split = str.split("\\.");
                //输出小数点前一位
                System.out.println(split[0].charAt(split[0].length()-1));
            }
    }
    /*split 方法的结果是一个字符串数组.
正常的写法是这样的:
1、如果用“.”作为分隔的话,必须是如下写法:String.split("\\."),这样才能正确的分隔开,不能用String.split(".");
2、如果用“|”作为分隔的话,必须是如下写法:String.split("\\|"),这样才能正确的分隔开,不能用String.split("|");
“.”和“|”都是转义字符,必须得加"\\";
3、如果在一个字符串中有多个分隔符,可以用“|”作为连字符,比如:“a=1 and b =2 or c=3”,把三个都分隔出来,可以用String.split("and|or");*/

/*1. 由 基本数据型态转换成 String

        String 类别中已经提供了将基本数据型态转换成 String 的 static 方法,也就是 String.valueOf() 这个参数多载的方法,有下列几种:
        String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串
        String.valueOf(char c) : 将 char 变量 c 转换成字符串
        String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
        String.valueOf(char[] data, int offset, int count) : 将 char 数组 data 中 由 data[offset] 开始取 count 个元素 转换成字符串
        String.valueOf(double d) : 将 double 变量 d 转换成字符串
        String.valueOf(float f) : 将 float 变量 f 转换成字符串
        String.valueOf(int i) : 将 int 变量 i 转换成字符串
        String.valueOf(long l) : 将 long 变量 l 转换成字符串
        String.valueOf(Object obj) : 将 obj 对象转换成 字符串, 等于 obj.toString()
        用法如:
        int i = 10;
        String str = String.valueOf(i);
        这时候 str 就会是 "10" 。


        2. 由 String 转换成 数字的基本数据型态

        要将 String 转换成基本数据型态,大多需要使用基本数据型态的包装类别,比如说 String 转换成 byte,可以使用 Byte.parseByte(String s) 这一类的方法。

        如果无法将 s 分析,则会丢出 NumberFormatException。

        byte :
        Byte.parseByte(String s) : 将 s 转换成 byte
        Byte.parseByte(String s, int radix) : 以 radix 为基底 将 s 转换为 byte 比如说 Byte.parseByte("11", 16) 会得到 17
        double :
        Double.parseDouble(String s) : 将 s 转换成 double
        float :
        Double.parseFloat(String s) : 将 s 转换成 float
        int :
        Integer.parseInt(String s) : 将 s 转换成 int
        long :
        Long.parseLong(String s)
 */

for 循环

//求出1~100之间的偶数和
public class Main {
    public static void main(String args[]) {
        int sum = 0;//用来累加的存钱罐
        for (int i = 1; i <= 100; i++){
            if (i % 2 == 0){//如果是偶数
                sum += i;
            }
        }
        System.out.println("结果是;" + sum);
    }
}

Switch-case的用法

package demo7;
import java.util.Scanner;
public class demo7YearMonthDays {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()){
            int y = sc.nextInt();
            int m = sc.nextInt();
            switch (m) {
                case 2:
                    if (y%100 == 0 && y%400 != 0 || y%4 != 0) {
                        System.out.println("28");
                    } else {
                        System.out.println("29");
                    }
                    break;
                case 4:
                    System.out.println("30");
                    break;
                case 6:
                    System.out.println("30");
                    break;
                case 9:
                    System.out.println("30");
                    break;
                case 11:
                    System.out.println("30");
                    break;
                default:
                    System.out.println("31");
                    break;
            }
        }
    }
}
/*Switch--case的用法*/
//匹配 就是全等。
/*
语法:
   switch(表达式){
     case 值1:
       表达式的值和 值1匹配上了,需要执行的代码;
       break;
     case 值2:
       表达式的值和 值2匹配上了,需要执行的代码;
     break;
     case 值3:
       表达式的值和 值3匹配上了,需要执行的代码;
     break;
     default:
       如果表达式的值和以上的case后面的值都没有匹配上,那么就执行这里的代码。
       break;
   }
   不写break会穿透到下一个break
 */


编程题

import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {//循环读入
            char c = in.next().charAt(0);//从字符串中取出一个字符
            if (c >= 'a' && c <= 'z') System.out.println("YES");
            else if (c >= 'A' && c <= 'Z') System.out.println("YES");
            else System.out.println("NO");
        }
    }
}
import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
    Scanner in = new Scanner(System.in);
    double a = in.nextDouble();
    int b = in.nextInt();
    int c = in.nextInt();
    int d = in.nextInt();
    double con = 1;
    /*计算双11 12是否有折扣*/
    if(b == 11 && c == 11) con = 0.7;
    if (b == 12 && c == 12) con = 0.8;
    if (d == 1) a = a * con - 50;
    else a = a * con;
    if (a < 0) a = 0.00;
    System.out.println(String.format("%.2f", a));//输出控制两位小数
    }
}


  • 水仙花数
import java.util.Scanner;
/*水仙花数*/
public class Main {
    public static void main(String args[]) {
        int i;
        for (i = 100; i < 1000; i++){
            int g = i % 10;
            int s = (i % 100) / 10;
            int b = i / 100;
            if (i == Math.pow(g,3) + Math.pow(s,3) + Math.pow(b,3))
                System.out.println(i);
        }
    }
}

import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
   Scanner in = new Scanner(System.in);
   while (in.hasNext()){
       char a = in.next().charAt(0);
       if (a == 'a' || a == 'A' || a == 'e' || a == 'E'|| a == 'i' || a == 'I' || a == 'o' || a == 'O' || a == 'u'
        || a == 'U')
           System.out.println("Vowel");
       else
           System.out.println("Consonant");
   }
    }
}


import java.util.Arrays;
import java.util.Scanner;
/* 数组的排序*/
public class Main {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        sc.nextLine();
        String s = sc.nextLine();
        String[] s1 = s.split(" ");
        Integer[] ss = new Integer[num];
        for(int i=0;i<num;i++) {
            ss[i] = Integer.valueOf(s1[i]);
        }
        Arrays.sort(ss);
        for(int i=ss.length-1;i>ss.length-6;i--) {
            System.out.print(ss[i]+" ");
        }
    }
}



import java.util.Scanner;
/*print 与 println的区别
1.输出方式不同。 Print在输出完信息不换行,Println在输出完信息自动换行。
               print将它的参数显示在命令窗口,并将输出光标定位在所显示的最后一个字符之后。
               println 将它的参数显示在命令窗口...
2.输出结果不同。 print是用于格式化输出的。
               println在要输出的内容后自动加了回车换行 ,这个函数不能用输出格式。*/
public class Demo1return{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        for (int i = 1; i <= 5;i++){
            for(int j=5-i;j>0;j--){
                System.out.print(" ");
            }
            for(int m=1;m<=i;m++)
                System.out.print(c+" ");
            System.out.println();
        }
    }
}
//考察循环执行的顺序并区别print 与 println .
import java.util.Scanner;
public class Demo1return{
    public static void main(String[] args){
       Scanner sc = new Scanner(System.in);
       String str = sc.next();
       String year = str.substring(0,4);
       String month = str.substring(4,6);
       String date = str.substring(6,8);
        System.out.println("year=" + year);
        System.out.println("month=" + month);
        System.out.println("date=" + date);
    }
}
/*字符串的substring使用方法
  1.substring(x)是从字符串的第x个字符截取
  2.substring(x,y)是从字符串的第x个字符到第y个字符位置的停止.
*/


package demo3;
import java.util.Scanner;
    public class subString{
        public static void main(String[] args){
            Scanner sc=new Scanner(System.in);
            int a = sc.nextInt();
            int b = sc.nextInt();
            if(a + b >= 100) {
                String s = String.valueOf(a + b);//将a+b相加后的int整型转换为String
                int length = s.length();
                if(s.charAt(length - 2) == '0') {  //如果s倒数第二位是0,则只输出最后一位
                    System.out.println(s.substring(length - 1));
                }else {
                    System.out.println(s.substring(length - 2));//如果s倒数第二位不是0,输出最后两位
                }
            }else {
                System.out.println(a + b);//a+b小于100,直接输出相加的结果
            }
        }
    }


package demo3;

import java.util.Scanner;

public class demo3repeat {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int sum_A = 0;
        int sum_B = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == 'A'){
                sum_A++;
            }else if (str.charAt(i) =='B'){
                sum_B++;
            }else{
                break;
            }
        }
        if (sum_A < sum_B){
            System.out.println("B");
        }else if (sum_A > sum_B){
            System.out.println("A");
        }else{
            System.out.println("E");
        }
    }
}

package demo1;

import java.util.Scanner;

public class demo1Second {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int seconds = sc.nextInt();
        if (seconds > 0 && seconds <= 100000000){
            int hour = seconds / 3600;
            int minute = (seconds - hour * 3600) / 60;
            int seconds1 = seconds - hour * 3600 - minute * 60;
            System.out.println(hour + " " + minute + " " + seconds1);
        }
    }
}

package demo1;
import java.util.Scanner;
public class demo1TotalScore {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        double score1 = sc.nextDouble();
        double score2 = sc.nextDouble();
        double score3 = sc.nextDouble();
        double totalScore = score1 + score2 + score3;
        double average = (score1 + score2 + score3) / 3;
        System.out.printf("%.2f ", totalScore);//保持两位小数,精度控制。
        System.out.printf("%.2f", average);//保持两位小数,精度控制。
    }
}

package demo5;
import java.util.Scanner;
public class demo5Change {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String s=sc.next();
            System.out.println(s.toLowerCase());
        }
    }
}
/*基本知识:对一个String对象使用toLowerCase方法,会得到一个新的String对象,内容是原来对象的小写形式。
同样的,原对象调用toUperCase方法,回得到新的String对象,其内容是原来对象的大写形式。
问题描述:java中字符串调用toLowerCase会不会修改原本的字符串
探究结果:不会
验证代码:
String string = new String("TEST");
string.toLowerCase();
System.out.println(string);
输出结果:TEST*/
package demo5;
import java.util.Scanner;
public class demo5Shifted {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            if (n >= 0 && n < 31) {
                System.out.println(2 << n - 1);
            }
        }
    }
}
package demo5;
import java.util.Scanner;
public class demo5Average {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            double[] myList = new double[5];//创建一个数组,里面可以储存5个double数据
            double total = 0;
            for (int i = 0; i < myList.length; i++) {
                myList[i] = sc.nextInt();//依次读取数组中的数据
                total += myList[i];
            }   //计算总和
            double average = total/myList.length;
            System.out.println(average);
        }
}

package demo6;
import java.util.Scanner;
import java.util.Arrays;
public class demo6HighestScore {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt())
        {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            int[] arr = {a,b,c};//如果不知道数组中的具体变量个数,用动态数组怎么找出最大值。
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) {//foreach在数组或集合上遍历变量。
                                                    //格式为:for(数组类型 变量名:数组名);
                                                    // 例如for(int i : arr)。
                if (arr[i]>arr[0]) max = arr[i];
            }
                System.out.println(max);
            //Arrays.sort(arr);//升序排列,Array.sort(int [] arr)对数组进行升序排列;
                             //降序排列,Arrays.sort(arr,Collections.reverseOrder());
            //System.out.println(arr[arr.length-1]);
        }
    }
}

package demo7;
import java.util.Scanner;
public class demo7Calculator {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            while (sc.hasNext()) {
                String s = sc.nextLine();
                    //正则切割
                String[] str = s.split("[+\\-*/]");
                if (str.length < 2){
                    //题目已交代了格式是“操作数 运算符 操作数”,所以不需要判断奇葩的不合法情况,例如"1+2:333"”
                    System.out.println("Invalid operation!");
                }else {
                    double a = Double.parseDouble(str[0]);
                    double b = Double.parseDouble(str[1]);
                    String opt = s.substring(str[0].length(),str[0].length()+1);
                    switch (opt){
                        case "+":
                            System.out.printf("%.4f" + opt + "%.4f=%.4f",a,b,a+b);
                            break;
                        case "-":
                            System.out.printf("%.4f"+opt+"%.4f=%.4f",a,b,a-b);
                            break;
                        case "*":
                            System.out.printf("%.4f"+opt+"%.4f=%.4f",a,b,a*b);
                            break;
                        default:
                            if (b==0){
                                System.out.println("Wrong!Division by zero!");
                            }else {
                                System.out.printf("%.4f"+opt+"%.4f=%.4f",a,b,a/b);
                            }
                            break;
                    }
                }
            }
        }
}


数学公式

$O(2^3) $
$\frac{1}{4}$
$\sqrt{16}$