1.基本类型包装类
package com.itheima00.question;
/*
I love java
me 2
*/
public class ToStringTest {
static int i = 1;
public static void main(String args[]) {
System.out.println("love " + new ToStringTest());
// 终极规则：string + object = string
// string + object.toString() = string //解释上行，先走toString()打印出"I"
// love + java //因为new ToStringTest()返回toString()（下面有写）即"java "
ToStringTest a = new ToStringTest();
a.i++; // 2，静态变量i被该类所有对象所共享
System.out.println("me " + ToStringTest.i); //类名.i
}
public String toString() {
System.out.print("I ");
return "java ";
}
}
Object是对象，如下三个统称为工具类。
工具类有个特点即方法都静态。
package com.itheima01.pack;
import java.util.Scanner;
/*
场景: 控制台/网页 输入的所有内容 对java程序都是字符串
面向对象: 解决问题,找到对象,然后调用方法来解决问题
我/猫 打开 门
打开行为 属于 门
* 基本类型包装类
* 1. 需求: 类型转换 : String - > int
* 2. 问题: int 基本类型 (没有属性和方法即没有打开行为)，预定义在jvm虚拟机中，连包都没有
* 3. Integer 引用类型，这样可以面向对象设置一些方法parseInt()，将类型转换方法设置到Integer中
* 基本: byte short int long float double char boolean
* 引用: Byte Short Integer Long Float Double Character Boolean （只有int,char不对应）
* 目的: 提供 string 转化成相应基本类型的方法。Integer：static int parseInt(String str) : 将字符串解析成int
*/
public class PackDemo {
public static void main(String[] args) {
// method01();
String str = "100";
int count = Integer.parseInt(str);//Integer是类即引用类型，parseInt静态方法，参数是字符串，返回int
// long l = Long.parseLong(str); // parse解析
System.out.println(count + 1); //101
}
private static void method01() {
System.out.println("请输入你的余额:");
Scanner sc = new Scanner(System.in);
// String str = sc.next();
// int s = Integer.parseInt(str);//String->int ,别的类型转为我自己int类型，方法设在int上
int s = sc.nextInt(); //nextInt()底层就是上面两行
System.out.println(s + 1);//101
}
}
package com.itheima01.pack;
/*
* JDK1.5特性:自动拆箱 : 在运算过程,Integer -> int
* 自动装箱 : 在赋值过程, int -> Integer
*/
public class PackDemo02 {
public static void main(String[] args) {
// method01();
Integer i1 = new Integer(200);
Integer i2 = new Integer(200);
System.out.println(i1 == i2);//false new出来:比的是地址
System.out.println(i1.equals(i2)); //true，Integer重写了equals
Integer i3 = 200; // 自动装箱 int ->Integer（Integer是引用数据类型有地址）
Integer i4 = 200; // 同上，这样i4可以调用toString，compareTo，intValue(很少用，用自动拆箱)等方法
System.out.println(i3 == i4);//false
System.out.println(i3.equals(i4));//true
/*
* Integer内部缓存池: cache
* -128 ~ 127(byte取值范围) 最常用（6种数据类型都包含这范围）
* 1. 如果创建一个Integer对象,那么先去缓存池中看看,有没有这个对象
* 2. 如果没有,就创建这个对象。如果有, 就直接返回这个对象
*/
Integer i5 = 100; // 0x0001 缓存池
Integer i6 = 100; //0x0001，i6.valueof点进源码可看见
System.out.println(i5 == i6);//true i5和i6的地址是一样
System.out.println(i5.equals(i6));//true
}
private static void method01() {
//Integer i = new Integer(200); //Integer作为一个引用类型应该要去new
Integer i = 200;// 自动装箱，等于上行，200基本类型自动变为对象即引用类型
int y = i + 1; // 自动拆箱
System.out.println(y);//201
}
}
2.集合
package com.itheima02.container;
import java.util.ArrayList;
// java容器：1. 数组 2. 集合（变，只对，不）
public class ContainerDemo {
public static void main(String[] args) {
int[] array = {
1,2,3};
Person[] array2 = {
new Person(),new Person()};
String[] array3 = {
"abc","bcd"};
Object[] array4 = {
"abc",new Person()}; // 多态: 向上转型，都转为Object类型
ArrayList<Integer> list = new ArrayList<>(); //ArrayList<Integer>泛型里不可写<int>基本数据类型
list.add(1);
list.add(2);//2自动装箱成引用数据类型
}
}
class Person{
}
package com.itheima03.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
/*
collection(东西收集在一起就是集合)常用方法 (不带索引)，以下方法是所有集合都具备
1. add
1. 添加元素，返回值boolean，成功为true
2. list中元素可重复，故恒为true。set中元素不可重复，有可能为false
2. clear
1. 清空集合中的所有元素。集合容器本身不会改变,继续使用
3. remove
1. 移除集合中的单个实例（参数obj），移除成功返回true
4. isEmpty
1. 判断当前集合的元素个数是否为0
5. contains
1. 包含某个元素，如果有返回true,区分大小写
6. size
1. 获取大小
7. toArray
1. 集合中的元素,变成数组。集合存储的数据类型不确定,返回的数组只能是Object
*/
public class CollectionDemo {
public static void main(String[] args) {
// method01();
//如下把Collection改为ArrayList，则coll.set就会有ArrayList特有的方法，Collection没有
Collection<String> coll = new ArrayList<>();//Collection是接口，不能实例化，所以只能创建子类对象
coll.add("张三");
coll.add("李四");
coll.add("王五");
//将集合中所有的元素放到数组中，数组有索引
Object[] objects = coll.toArray();
for (int i = 0; i < objects.length; i++) {
Object element = objects[i];
System.out.println(element);
}
}
private static void method01() {
//编译看左边: 父类无法调用子类特有方法。所以把学习的方法限制于Collection集合内，不会用到ArrayList特有的方法
Collection<String> coll = new ArrayList<>(); //ArrayList改为HashSet，则若加add两个张三则报错
coll.add("张三");
coll.add("李四");
coll.add("王五");
boolean result = coll.add("马六"); //添加成功返回true,失败为false(基本没用)
System.out.println(result);
System.out.println(coll);//[张三，李四...]引用类型打印不是内存地址必然重写了toString方法
//coll.clear(); //清空集合中所有的元素
//System.out.println(coll); //[] 空篮子
//System.out.println(coll == null); // false 篮子还在
boolean result2 = coll.remove("马六"); //移除成功返回true(基本没用)
System.out.println(result2);
System.out.println(coll);
System.out.println(coll.size()); // 3
System.out.println(coll.isEmpty()); //false
//如果集合中包含某个元素,就返回true
boolean result3 = coll.contains("李四");
System.out.println(result3);
}
}
hasNext()返回true就调用next()，迭代器不断运行直到返回false。
package com.itheima04.iterator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 遍历: 全部经历
* 迭代: 相同的动作不断执行。版本迭代：开发 -> 测试 -> 上线 1.0。开发 -> 测试 -> 上线 2.0 ...
* 迭代器 : 不断循环的机器 iterator
* 1. boolean hasNext(); 判断是否有下一个元素,如果有,就返回true
* 2. 元素 next(); 向后移动一位,并获取当前元素
* Collection方法，如下E是泛型返回值
* Iterator<E> iterator() : 返回在此collection的元素上进行迭代的迭代器。
* 以前for循环基于索引，Collection没有索引，但有迭代器好用
*/
public class IteratorDemo {
public static void main(String[] args) {
// method01();
Collection<String> coll = new ArrayList<>();
coll.add("张三");
coll.add("李四");
coll.add("王五");
Iterator<String> it = coll.iterator();
while(it.hasNext()){
//while取代下面的几次if循环
String name = it.next();
System.out.println(name);
}
}
private static void method01() {
Collection<String> coll = new ArrayList<>();
coll.add("张三");
coll.add("李四");
coll.add("王五");
//获取collection集合的迭代器（相当于指针）
Iterator<String> it = coll.iterator();
//第一次迭代
if (it.hasNext()){
String name = it.next();
System.out.println(name); //张三
}
//第二次迭代
if (it.hasNext()){
String name = it.next();
System.out.println(name);//李四
}
//第三次迭代
if (it.hasNext()){
String name = it.next();
System.out.println(name); //王五
}
//第四次迭代，it.hasNext()返回false
if (it.hasNext()){
String name = it.next();
System.out.println(name);
}
}
}
匿名内部类也是语法糖，将定义类和创建对象合二为一。
s1地址先赋给s2，s2地址后又改变了。
package com.itheima05.foreach;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
/*
* 增强for循环:
* 1. 前置
* 1. 普通for循环 : fori快捷键
* for (int i = 0; i < 10; i++) {
list.set(i,"马六"); //可以修改
}
2. 语法糖(syntax sugar) : 原理相同,但是更为简练的语法
2. for...each 快捷键array.for
1. 集合 : 作为迭代器的语法糖
collecition支持增强for循环
语法:
for(元素类型 变量名 : 被遍历的集合){
}
代价: 只适合用来查 (不适合用来修改集合内容)
2. 数组 : 作为普通for循环的语法糖
*/
public class ForeachDemo {
public static void main(String[] args) {
// method01();
int[] array = {
1, 2, 3};
/* for (int i = 0; i < array.length; i++) {
int element = array[i];
element = 10;
System.out.println(element); //10
array[i] = 10;
System.out.println(array.toString()); //[I@14ae5a5
System.out.println(Arrays.toString(array)); // [10, 2, 3]，[10, 10, 3]，[10, 10, 10]
}
System.out.println(Arrays.toString(array)); //[10, 10, 10] */
for (int element : array) {
//1
System.out.println(element); //2
} //3
System.out.println(Arrays.toString(array)); //[1,2,3]
}
private static void method01() {
Collection<String> coll = new ArrayList<>();
coll.add("张三");
coll.add("李四");
coll.add("王五");
/* Iterator<String> it = coll.iterator();
while(it.hasNext()){
String name = it.next(); //这行相当于get方法
name = "马六";
System.out.println(name); //马六 马六 马六
}
System.out.println(coll); //依然还是[张三，李四，王五] */
//下面代码称为上面代码语法糖
for(String name : coll){
//name会被coll里面的每一个元素循环赋值
//System.out.println(name);
name = "马六";
}
System.out.println(coll); //依然还是[张三，李四，王五]
}
}
B站/知乎/微信公众号：码农编程录
