Java复习3

最新推荐文章于 2021-08-16 12:57:23 发布

月满西楼l

最新推荐文章于 2021-08-16 12:57:23 发布

阅读量130

点赞数

本文链接：https://blog.csdn.net/qq_40859235/article/details/81157334

版权

这一次主要复习java的两个包，一个是Lang，一个是Util

还是与上次一样，先上思维导图

先看Lang包

1.装箱与拆箱

基本数据类型，如int,float,double,boolean,char,byte,不具备对象的特征，不能调用方法，比如List中只能调用对象不能直接调用数值，所以需要对其进行包装，称为装箱。

装箱：将基本类型转换成包装类对象

int i=1;

Integer x=new Integer(i);//手动装箱

Integer y=1;//自动装箱

拆箱：将包装类对象转换成基本类型的值

Integer i=new Integer(10);

int m=i.intValue();//手动拆箱

int n=i;//自动拆箱

//以上部分参考了bili111的文章https://www.cnblogs.com/james111/p/6607400.html

那么装箱之后变成什么样了呢？以下是八种基本类型包装之后的名字

byte——Byte
short——Short
int——Integer
long——Long
float——Float
double——Double
boolean——Boolean
char——character

以下是一些例子和说明：

package Afternoon;

public class Test1 {
	public static void main(String[] args) {
		//构造方法创建对象
		Integer i = new Integer(10);
		System.out.println(i);
		//可以接受空值
		i = null;
		//包装类型和基本类型之间可以自由转换
		//自动装箱
		Integer a = 20;//new Integer(20);
		//自动拆箱
		int b = new Integer(30);
		//可以将字符串解析成数值类型
		int num = Integer.parseInt("666");
		System.out.println(num);
		Integer num2=Integer.valueOf("888");
		System.out.println(num2);
	}
}

2.equals（）方法

==比较的是地址值
equals（）方法比较的是对象内容，创建一个必须重写从Object继承过来的equals（）方法，才能比较对象内容

例：

package Afternoon;

public class Test3 {
public static void main(String[] args) {
	String s1 = new String("Hello");
	String s2 = new String("Hello");
	System.out.println(s1==s2);//比较地址值
	System.out.println(s1.equals(s2));//比较对象的内容
}
}

3.String

查询位置
IndexOf：从头开始查询
lastIndexOf：从尾部开始查询

例：

package Afternoon;

public class Test4 {
	public static void main(String[] args) {
		String str = "Java是一门面向对象编程语言，Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程";
		// 搜索第一个java的位置
		int idx = str.indexOf("Java", 0);
		System.out.println("第一个“Java”的位置是："+idx);
		// 搜素第二个java的位置
		idx = str.indexOf("Java", idx + 1);
		System.out.println("第二个“Java”的位置是："+idx);
		// 搜索倒数第一个面向对象
		int idx2 = str.lastIndexOf("面向对象");
		System.out.println("最后一个“面向对象”的位置是："+idx2);
		// 搜索倒数第二个面向对象
		idx2 = str.lastIndexOf("面向对象", idx - 1);
		System.out.println("倒数第二个“面向对象”的位置是："+idx2);
	}
}

更改：字符串一但创建就不能改变，所有的拼接和修改都是创建新的对象如果频繁的拼接或修改，会产生大量的中间对象，造成内存溢出为解决此问题，使用StringBuffer可变字符串

package Afternoon;

public class Test6 {
	public static void main(String[] args) {
		// String s = "Hello";
		// System.out.println(s.hashCode());
		// s += "world";
		// System.out.println(s.hashCode());//字符串已经被修改
		// System.out.println(s);
		StringBuffer s = new StringBuffer("Hello");
		System.out.println(s.hashCode());
		s.append("world");
		System.out.println(s.hashCode());
		System.out.println(s);

	}
}

再来看有关Util包的内容

1.Scanner

例1：输入字符串，判断大小写，数字，其它

isUpperCase()判断是否为大写字母

isLowerCase()判断是否为小写字母

isDigit()判断是否为数字

这些方法我们都可以查询的到，按住ctrl，再将鼠标移至方法上点击即可跳转

package Afternoon;

/**
 * 从控制台输入一个字符串，统计有多少个大写字母，小写字母，数字，其他字符
 */
import java.util.Scanner;

public class Test2 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个字符串");
		String str = sc.nextLine();
		int[] counts = new int[4];
		// 将字符串str拆成字符数组
		char[] chs = str.toCharArray();
		// 增强for循环，每一次循环都从chs里拉出来一个值赋值给c
		for (char c : chs) {
			if (Character.isUpperCase(c)) {//判断是否为大写字母
				counts[0]++;
			} else if (Character.isLowerCase(c)) {//判断小写字母
				counts[1]++;
			} else if (Character.isDigit(c)) {//判断数字
				counts[2]++;
			} else {
				counts[3]++;
			}
		}
		System.out.println("大写字母的数字是：" + counts[0]);
		System.out.println("小写字母的数字是：" + counts[1]);
		System.out.println("数字的数字是：" + counts[2]);
		System.out.println("其他字符的数字是：" + counts[3]);
	}

}

例2：判断回文

再次用到equals()方法

package Afternoon;

import java.util.Scanner;

public class Test7 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个回文：");
		String str = sc.nextLine();
		StringBuffer s = new StringBuffer(str);
		String str2 = s.reverse().toString();
		if (str.equals(str2))
			System.out.println("你输入的是回文。");
		else
			System.out.println("你输入的不是回文。");
	}
}

2.Arrays

例：规范姓名——首字母大写，其他字母小写

package Afternoon;

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

public class Test5 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String[] arr = new String[3];
		for (int i = 0; i < 3; i++) {
			System.out.println("请输入第" + (i + 1) + "个英文名");
			arr[i] = sc.nextLine();
		}
		System.out.println("原始的英文名是：" + Arrays.toString(arr));
		for (int i = 0; i < arr.length; i++) {
			String name = arr[i];
			// (name.charAt(0)+"").toUpperCase() 首字符大写
			// name.substring(1, 3).toLowerCase() 其余字符小写
			arr[i] = (name.charAt(0) + "").toUpperCase() + name.substring(1).toLowerCase();
		}
		System.out.println("规范后的英文名是：" + Arrays.toString(arr));
	}
}

3.有关数据库的调用举例

package Afternoon;

import java.util.Scanner;

public class Test8 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入姓名：");
		String name = sc.nextLine();
		System.out.print("请输入年龄：");
		String age = sc.nextLine();
		String sql = pingSQL(name, age);
		System.out.println(sql);
	}

	private static String pingSQL(String name, String age) {
		StringBuffer s = new StringBuffer("select * from emp where 1=1");
		if (name != null && !"".equals(age)) {
			s.append("ane age=" + age);
		}
		return s.toString();
	}

}

4.Date

封装了日期与时间的信息
日期：年，月，日
时间：时，分，秒，毫秒
Date date = new Date();//当前系统时间

SimpleDateFormat（日期格式器）
   yyyy表示年
   MM表示月
   dd表示日
   HH24小时制
   hh12小时制
   mm分
   ss秒

例：

package Afternoon;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test9 {
	public static void main(String[] args) {
		Date d = new Date();
		System.out.println(d);
		System.out.println(d.toLocaleString());
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 ahh时mm分ss秒");
		String dateStr = sdf.format(d);
		System.out.println(dateStr);
	}
}

5.Calendar

(1)年份，月份，日期的偏移

package Afternoon;

import java.util.Calendar;

public class Test10 {
	public static void main(String[] args) {
		// 创建一个日历对象
		Calendar cal = Calendar.getInstance();
		int year = cal.get(Calendar.YEAR);
		System.out.println(year);
		int month = cal.get(Calendar.MONTH);
		// 0-11
		System.out.println(month);
		int date = cal.get(Calendar.DATE);
		System.out.println(date);
		//修改年份
		cal.set(Calendar.YEAR, 2016);
		//月份偏移,往后加，往前减
		cal.add(Calendar.MONTH, 2);
		//日期偏移
		cal.add(Calendar.DATE, 3);
	}
}

(2)打印当月日历

package Afternoon;

import java.util.Calendar;

/**
 * 打印日历
 */
public class Test11 {
	public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();
		// 将时间移动到本月的第一天
		cal.set(Calendar.DAY_OF_MONTH, 1);
		// 本月第一天在所在周是第几天
		int start = cal.get(Calendar.DAY_OF_WEEK);
		// 打印日历头
		System.out.println("日\t一\t二\t三\t四\t五\t六");
		for (int i = 1; i <= 7 * 6; i++) {
			if (i < start) {
				System.out.println("\t");
				continue;
			}
			System.out.print(cal.get(Calendar.DATE) + "\t");
			// 打印7天空一行
			if (i % 7 == 0) {
				System.out.println();
			}
			//判断是否到月末
			if (cal.get(Calendar.DATE) == cal.getActualMaximum(Calendar.DAY_OF_MONTH)) {
				break;
			}
			// 日期的值增加
			cal.add(Calendar.DATE, 1);

		}
	}
}

6.集合框架

数组的缺陷
   数组一旦创建，长度不可改变
   数组存储的数据必须是同一类型
   数组只能存储数据，没有封装对数据的操作

因此我们常用集合而不用数组

泛型：

泛型即参数化类型，将原来要调用的具体类型参数化，减少了在强制转换类型中所带来的编译错误。

package Afternoon;

import java.util.ArrayList;
import java.util.List;

/**
 * 泛型
 */
public class Genericity {
	public static void main(String[] args) {
		List<Employee> es = new ArrayList<Employee>();
		es.add(new Employee());
	}
}

其中Employee类为：

package Afternoon;

public class Employee {
	private long id;
	private String name;
	private String sex;
	private int age;
	private int salary;
	private String dep;

	public Employee() {
		super();
	}

	public Employee(long id, String name, String sex, int age, int salary, String dep) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.salary = salary;
		this.dep = dep;
	}

	public void printInfo() {
		System.out.println(id + "," + name + "," + sex + "," + age + "," + salary + "," + dep);
	}

	public void addsalary(int salary) {
		this.salary += salary;
	}
}

(1)单列数据（Collection）
   List：有索引维护，有序数据可以重复
       ArrayList：线性表（动态数组），主要用于查询
       LinkedList，适合修改较多的情况
   set：没有索引维护，无序，数据不可重复
       存放在set中的对象必须实现equals（）方法和hashcode（）方法

List例：

遍历与删除

package Afternoon;

import java.util.ArrayList;

public class List {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add(12);
		list.add("java");
		//遍历集合
		//size()：获得集合中对象的数量
		for(int i=0;i<list.size();i++)
		{
			Object o=list.get(i);
			System.out.println(o);
		}
		//删除集合中的对象
		//通过索引删除
		list.remove(0);
		list.remove("java");
		System.out.println(list.size());

	}
}

循环删除链表


package Afternoon;

import java.util.ArrayList;

public class Test {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		list.add(6);
		list.add(7);
		list.add(8);		
		System.out.println("删除前的长度为"+list.size());
	    int length = list.size();
		for(int i = 0;i<length;i++)
		{
			list.remove(length-(i+1));
		}
		System.out.println("删除后的长度为"+list.size());
	}
}

set例：

package Afternoon;

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

public class Set1 {
	public static void main(String[] args) {
		Set<String> sets = new HashSet<String>();
		/**
		 * 因为String类型重写了Object类的equals()方法和hashCode()方法，所以能够存放在HashCode中去实现去重效果，其他类型也一样
		 */
		sets.add("java");
		sets.add(".net");
		System.out.println(sets.size());
		sets.add("java");
		// set方法不能输入相同的字符，长度不会增加
		System.out.println(sets.size());
		sets.add("Java");
		System.out.println(sets.size());
		// 取值
		for (String s : sets) {
			System.out.println(s);
		}
		// 由于迭代器太繁琐，故将其封装成加强for循环
		// 迭代器
		// Iterator<String> it = sets.iterator();
		// while(it.hasNext()) {
		// String str = it.next();
		// System.out.println(str);
		// }
	}
}

(2)集合排序

package Afternoon;

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

//集合排序
public class Sort {
	public static void main(String[] args) {
		List<Integer> List = new ArrayList<Integer>();
		List.add(33);
		List.add(45);
		List.add(27);
		List.add(66);
		List.add(17);
		List.add(79);
		System.out.println("排序前：");
		for (Integer i : List) {
			System.out.println(i);
		}
		Collections.sort(List, new MyComparator());//回调模式
		//排序后
		System.out.println("排序后：");
		for (Integer i : List) {
			System.out.println(i);
		}
	}
}

class MyComparator implements Comparator<Integer> {
	/**
	 * num1 和 num2是集合中相邻的两个对象，在排序的时候会做比较以确定谁先谁后 如果返回值大于0，num1和num2就交换，反之则保持原样
	 */
	public int compare(Integer num1, Integer num2) {
		return num1 - num2;
	}

}

(3)双列数据（键值对，Map）
Hash Map是在HashSet的基础上构建的，通过key来存储value
key不能重复，如果重复则后一个键值对会将前一个覆盖掉

key例：

package Afternoon;

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

/**
 * HashMap
 */
public class Key {
	public static void main(String[] args) {
		// 创建map对象
		Map<String, Integer> map = new HashMap<String, Integer>();
		// 向map中添加数据key-value
		map.put("java", 1);
		map.put("c/c++", 2);
		map.put(".net", 3);
		map.put("php", 4);
		map.put("javascript", 5);
		System.out.println(map.size());
		// 字符串重写equals()方法和hashcode()方法，故直接替换
		map.put("java", 66);
		System.out.println(map.size());
		// 通过key来删除整个键值对
		map.remove(".net");
		System.out.println(map.size());
		// 遍历
		// 1:
		// keySet()将map中所有的key封装成一个set集合
		Set<String> sets = map.keySet();
		for (String key : sets) {
			// get(key) 通过key获得value
			Integer value = map.get(key);
			System.out.println(key + ":" + value);
		}
		System.out.println("----------------------------");
		// 2:<Entry<String, Integer>> 
		//Entry就是键值对类型
		//将所有的key--value封装成set
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for(Entry<String,Integer> ey:entrySet) {
			System.out.println(ey.getKey()+":"+ey.getValue());
		}
	}
}

判断一个字符串中的元素出现过几次

package Afternoon;

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

public class Statistics {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入一个字符串：");
		String str = sc.nextLine();
		// 将str转换成字符数组
		char[] chs = str.toCharArray();
		// 将字符数组中的元素放入hashmap中
		Map<Character, Integer> map = new HashMap<Character, Integer>();
		for (int i = 0; i < chs.length; i++) {
			Integer num = map.get(chs[i]);
			if (num == null)
				// 第一次遇到这个字符
				map.put(chs[i], 1);
			else
				// 不是第一次遇到这个字符
				map.put(chs[i], num + 1);		
		}
		System.out.println(map);
		// 遍历map
		Set<Character> keys = map.keySet();
		for (Character c : keys) {
			System.out.println(c + ":" + map.get(c));
		}
	}
}

月满西楼l

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java复习3

这一次主要复习java的两个包，一个是Lang，一个是Util还是与上次一样，先上思维导图先看Lang包1.装箱与拆箱基本数据类型，如int,float,double,boolean,char,byte,不具备对象的特征，不能调用方法，比如List中只能调用对象不能直接调用数值，所以需要对其进行包装，称为装箱。装箱：将基本类型转换成包装类对象int i=1;Int...
复制链接

扫一扫