java基础
- 面向对象
- 封装、继承、多态
- 封装
- 类,模板、图纸
- 对象,实例
- 引用,遥控器
- 构造方法
- 新建对象时执行
- 不定义有默认
- 作用:任意功能都可以
- 常见作用:为成员变量赋值
- this
- this.xxx
- 引用当前对象的地址
- this(…)
- 构造方法之间调用
- this.xxx
- 方法重载 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
- List 接口
- Map 接口
- HashMap
- TreeMap
- Iterator 接口
- Collections 工具类
- Collection 接口
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
- List 接口
- 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,希望每个从我这边都有收获,然后点上一个小小赞,关注,共同进步,谢谢