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中的进制转换
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);
}
}
}
}
哈希表的数据结构
- 哈希值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集合的常用方法
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（）
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（）
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("后续代码");
}
}
- 异常处理原理
-
- Object的非空判断
- Java异常的第一种处理方式Throws
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
- Finally代码块
00