java基础09

北木楠-

已于 2022-03-27 16:00:37 修改

阅读量118

点赞数 2

文章标签： java 开发语言后端

于 2021-10-30 09:37:15 首次发布

本文链接：https://blog.csdn.net/m0_46435451/article/details/121046737

版权

java基础

面向对象
- 封装、继承、多态
封装
- 类，模板、图纸
- 对象，实例
- 引用，遥控器
- 构造方法
  - 新建对象时执行
  - 不定义有默认
  - 作用：任意功能都可以
  - 常见作用：为成员变量赋值
- this
  - this.xxx
    - 引用当前对象的地址
  - this(…)
    - 构造方法之间调用
- 方法重载 Overload
  - 同名不同参
- private
  - 私有、隐藏

毫秒值表示的时间
System.currentTimeMillis()
1970-1-1 0点开始的毫秒值
可以把毫秒值封装到 java.util.Date 对象

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Scanner;

 

public class Test1 {

   public static void main(String[] args) {

      System.out.print("输入毫秒值：");

      long t = new Scanner(System.in).nextLong(); 

      //把 t 封装到 java.util.Date

      //new Date();//无参构造，封装当前时间毫秒值

      Date d = new Date(t);//有参，封装指定毫秒值

      System.out.println(d);//默认调d.toString()

     

      //把 Date 对象，处理成指定格式的字符串

      /*

       * dd/MM/yyyy

       * MM/dd/yyyy

       * yyyy年MM月dd日

       *

       * yy-M-d H:m

       */

      SimpleDateFormat sdf =

       new SimpleDateFormat(

       "yyyy-MM-dd HH:mm:ss");

      //调用格式工具的格式化方法

      //把Date对象格式化成指定格式字符串

      String s = sdf.format(d);

      System.out.println(s);

   }

}

1 内部类

嵌套定义在类内部，或方法内部，或局部代码块内部的类
非静态内部类
静态内部类
局部内部类
匿名内部类

1.1 非静态内部类

class A {

  class Inner {

}

}

Inner对象，必须依赖于外部对象才能存在
不能独立创建对象
Inner 对象，属于一个 A 对象
非静态内部类中，不能定义静态成员

A a1 = new A()

A a2 = new A()

Inner i = a1.new Inner();

1.2 静态内部类

class A {

static class Inner {

}

静态内部类，可以独立创建对象

Inner i = new Inner();

1.3 局部内部类

定义在局部代码块中的类型，只能在局部使用

 

class A {

   Weapon f() {

      class Inner implements Weapon {

}

 

Inner i = new Inner();

return i;

}

}

 

A a = new A();

Weapon w = a.f();

1.4 匿名内部类

Weapon w = new Weapon() {};

大括号：匿名类
new：新建匿名类的对象
Weapon：父类型
小括号：super()、super(参数)

内部类
import day1302.A.Inner1;

import day1302.A.Inner2;

 

public class Test1 {

   public static void main(String[] args) {

      /*

       * 静态内部类可以独立使用，独立创建对象

       */

      Inner1 i1 = new Inner1();

      System.out.println(i1);//默认调用 i1.toString()

      /*

       * 非静态内部类属于对象，

       * 不能独立创建对象，

       * 必须依赖外部对象才能存在

       */

      A a1 = new A();

      A a2 = new A();

      Inner2 i2 = a1.new Inner2();

      System.out.println(i2);

   }

}//Test1结束

 

class A {

   static class Inner1 {

     

   }

   class Inner2 {

     

   }

}

 
 
 //测试
 
 public class Test2 {

   public static void main(String[] args) {

      Weapon w1 = f1();

      System.out.println(w1);

      w1.kill();

     

      System.out.println("---------------");

     

      Weapon w2 = f2("方天画戟");

      System.out.println(w2);

      w2.kill();

   }

 

   private static Weapon f2(String name) {

      /*

       * *) 大括号：匿名类

       * *) new: 新建匿名类的对象

       * *) Weapon: 父类型

       * *) 小括号: super()、super(参数)

       *

       * 局部内部类中，使用外面的一个局部变量

       * 必须加 final

       * jdk1.8 缺省

       */

      Weapon w = new Weapon() {

         @Override

         public void kill() {

            System.out.println(

             "使用"+name+"进攻");

         }

      };

     

      return w;

     

   }

  

  

  

 

   private static Weapon f1() {

      class AK47 implements Weapon {

         @Override

         public void kill() {

            System.out.println("使用AK47进攻");

         }

      }

      //局部的类型，只能在局部使用

      //但是他的对象，可以作为父类型向外传递

      AK47 a = new AK47();

      return a;

   }

}

匿名内部类
ArrayList集合中存放一组数字格式的字符串，

排序

"1"

"10"

"11"

"2"

"20"

"21"

"3"


import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

 

public class Test3 {

   public static void main(String[] args) {

      ArrayList<String> list = new ArrayList<>();

      //一次向 list 加入多个值

      Collections.addAll(

        list,"11","21","12","31","1",

        "2","30","22","10","3","20");

     

      System.out.println(list);

     

      Collections.sort(list);

      System.out.println(list);

     

      Comparator<String> c = new Comparator<String>() {

         /*

          * 返回值的规则

          * o1大，返回正数

          * o1小，返回负数

          * 相同，返回0

          */

         @Override

         public int compare(String o1, String o2) {

            int a = Integer.parseInt(o1);

            int b = Integer.parseInt(o2);

            return a-b;

         }

      };

     

      /*

       * 比较器对象c

       * 被传递到 sort() 方法内，

       * 在 sort() 内部会调用 c.compareTo(...)

       * 并根据该方法结果来判断数据的大小

       */

      Collections.sort(list, c);

      System.out.println(list);

   }

}

2 集合

用来存放一组数据
继承结构
- Collection 接口
  - List 接口
    - ArrayList
    - LinkedList
  - Set 接口
    - HashSet
    - TreeSet
- Map 接口
  - HashMap
  - TreeMap
- Iterator 接口
- Collections 工具类

3 LinkedList

双向链表
两端效率高
方法
- add(数据)
- add(i, 数据)
- get(i)
- remove(i)
  - 移除指定位置数据
    
    返回被移除的值
- remove(数据)
  - 找到第一个相等数据移除
    
    返回布尔值，表示是否找到数据并移除
- size()
- 元素的数量
- iterator()
  - 辅助创建迭代器对象的方法
- addFirst(), addLast()
- getFirst(), getLast()
- removeFirst(), removeLast()
- 队列 Queue，FIFO
  - offer(), addLast()
  - peek(), getFirst()
  - poll(), removeFirst()
- 栈 Stack，LIFO
- push(), addFirst()
- pop(), removeFirst()

LinkedList

import java.util.Iterator;

import java.util.LinkedList;

 

public class Test1 {

   public static void main(String[] args) {

      LinkedList<String> list = new LinkedList<>();

      list.add("aaa");

      list.add("rrr");

      list.add("ggg");

      list.add("aaa");

      list.add("ccc");

      list.add("aaa");

      list.add("eee");

      list.add("kkk");

      System.out.println(list.size());

      System.out.println(list);

      System.out.println(list.get(0));

      System.out.println(list.get(list.size()-1));

      System.out.println(list.remove(2));

      System.out.println(list);

      System.out.println(list.remove("aaa"));

      System.out.println(list);

      //双向链表下标遍历效率低

      for(int i=0;i<list.size();i++) {

         System.out.println(list.get(i));

      }

     

      //双向链表迭代器遍历效率高

      //新建list的迭代器对象

      Iterator<String> it = list.iterator();

      //当还有数据

      while(it.hasNext()) {

         String s = it.next();

         System.out.println(s);

      }

     

   }

}


//测试
import java.util.Iterator;

import java.util.LinkedList;

 

public class Test2 {

   public static void main(String[] args) {

      /*

       * Integer.valueOf(1)

       * 一个对象，重复放入双向链表，放入10万次

       */

      LinkedList<Integer> list =

       new LinkedList<>();

      for (int i = 0; i < 100000; i++) {

         list.add(1);

      }

     

      ///

      System.out.println("--下标遍历-------------");

      f1(list);

      System.out.println("--迭代器遍历-------------");

      f2(list);

   }

 

   private static void f1(LinkedList<Integer> list) {

      long t = System.currentTimeMillis();

      for(int i=0;i<list.size();i++) {

         list.get(i);

      }

      t = System.currentTimeMillis()-t;

      System.out.println(t);

   }

 

   private static void f2(LinkedList<Integer> list) {

      long t = System.currentTimeMillis();

      Iterator<Integer> it = list.iterator();

      while(it.hasNext()) {

         it.next();

      }

      t = System.currentTimeMillis()-t;

      System.out.println(t);

     

   }

}

丑数

2,3,5 

6355250/2/2/2/3/3/5/5/5
2,3,4,5,6,8,9,10,12,15,16,18,20...
 


import java.util.LinkedList;

import java.util.Scanner;

 
public class Test1 {

   public static void main(String[] args) {

      System.out.print("求第几个丑数：");

      int n = new Scanner(System.in).nextInt();

      long r = f(n);

      System.out.println(r);

   }

 

   private static long g(int n) {

      int count = 0;

      for(long i=2; ;i++) {

         //i是否是丑数

         if(chouShu(i)) {

            count++;

            if(count == n) {

                return i;

            }

         }

      }

   }

  

   private static boolean chouShu(long i) {

      while(i%2 == 0) {

         i /= 2;

      }

      while(i%3 == 0) {

         i /= 3;

      }

      while(i%5 == 0) {

         i /= 5;

      }

      return i == 1;

   }

 

  

  

  

  

   private static long f(int n) {

      /*

       * 10 xx xx xx

       * ---------------

       * 12 15 xx xx xx

       * ---------------

       * 10 15 20 25 xx xx xx

       * ---------------

       *

       * 2 3 4 5 6 8 9

       *

       * *)准备三个集合，用来存放2,3,5的倍数

       * *)初始状态，先放入2,3,5

       *

       * *)从头部移除最小值

       * *)最小值乘2,3,5，放入三个集合

       */

      LinkedList<Long> list2 = new LinkedList<>();

      LinkedList<Long> list3 = new LinkedList<>();

      LinkedList<Long> list5 = new LinkedList<>();

      list2.add(2L);

      list3.add(3L);

      list5.add(5L);

     

      long r = 0;

     

      //从第1个，求到第n个

      for(int i=1;i<=n;i++) {

         //移除头部的最小值

         long a = list2.getFirst();

         long b = list3.getFirst();

         long c = list5.getFirst();

         r = Math.min(a, Math.min(b, c));

         if(r == a) list2.removeFirst();

         if(r == b) list3.removeFirst();

         if(r == c) list5.removeFirst();

         //r乘2,3,5放入集合

         list2.add(r*2);

         list3.add(r*3);

         list5.add(r*5);

      }    

      return r;   

   }

}

4 ArrayList 和 LinkedList

Collection 接口
- List 接口
  - ArrayList
  - LinkedList
ArrayList
- 访问任意位置效率高
- 增删数据，效率可能降低
LinkedList
- 两端效率高
如果仅在两端操作数据，使用 LinkedList
当数据量小时（<10），频繁增删数据，使用LinkedList

5 HashMap（重点）

哈希表，散列表
存放“键值对”数据
哈希表的作用：
用键，快速定位数据，提取对应的值

s = map.get(9527)
键：
- 不重复
- 无序
方法：
- put(key, value)
  
  放入键值对数据
  
  放入重复的键，会用新值替换旧值
- get(key)
  
  提取指定键对应的值
  
  键不存在，得到 null 值
- remove(key)
移除一对数据，并返回被移除的值
- size()

HashMap

import java.util.HashMap;

 

public class Test1 {

   public static void main(String[] args) {

      HashMap<Integer, String> map = new HashMap<>();

      map.put(9527, "唐伯虎");

      map.put(9528, "华夫人");

      map.put(9529, "祝枝山");

      map.put(9530, "旺财");

      map.put(9531, "小强");

      map.put(9532, "石榴姐");

      map.put(9533, "秋香");//旧爱

      map.put(9533, "如花");//新欢

      map.put(9535, null);

      map.put(null, "---");

      System.out.println(map.size());

      System.out.println(map);

      System.out.println(map.get(9527));

      System.out.println(map.get(9999));

      System.out.println(map.remove(9531));

      System.out.println(map);

   }

}

 

 

 

字符串中的字符统计

"abacded"

    i

 

key  value

a     2

b     1

c     1




//测试

import java.util.HashMap;

import java.util.Scanner;

 

public class Test2 {

   public static void main(String[] args) {

      System.out.println("输入：");

      String s = new Scanner(System.in).nextLine();

     

      HashMap<Character, Integer> map = new HashMap<>();

      for(int i=0;i<s.length();i++) {

         //取出字符串中i位置字符

         char c = s.charAt(i);

         //从map取该字符对应的计数值，不存在得到null

         Integer count = map.get(c);

         if(count == null) {//没有该字符的计数

            map.put(c, 1);//它是第一个字符

         } else {

            map.put(c, count+1);//计数加一，覆盖原值

         }

      }

     

      System.out.println(map);

   }

}

以实战来学习java，希望每个从我这边都有收获，然后点上一个小小赞，关注，共同进步，谢谢

北木楠-

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
java基础09

java基础面向对象封装、继承、多态封装类，模板、图纸对象，实例引用，遥控器构造方法新建对象时执行不定义有默认作用：任意功能都可以常见作用：为成员变量赋值thisthis.xxx引用当前对象的地址this(…)构造方法之间调用方法重载 Overload同名不同参private私有、隐藏毫秒值表示的时间System.currentTimeMillis()1970-1-1 0点开始的毫秒值可以把毫秒值封装到 ja
复制链接

扫一扫