package demo04;
/**
* 1、试编写Java代码实现一个计数器类Computer其中包括：
域value ：用来保存计数器的当前值；
方法increment()： 计数器加一；
方法decrement() ：计数器减一；
方法reset()：计数器清零。
* @author tom
*
*/
public class Computer {
private int value;//默认值0
public Computer() {
super();
// TODO Auto-generated constructor stub
}
public Computer(int value) {
super();
this.value = value;
}
public void increment(){
this.value++;
}
public void decrement(){
this.value--;
}
public void reset(){
this.value = 0;
}
@Override
public String toString() {
return this.value+"";
}
}
package demo04;
public class TestComputer {
public static void main(String[] args) {
Computer cp = new Computer();
System.out.println("自增开始");
for (int i = 0; i <10; i++) {
cp.increment();
System.out.println(cp);
}
System.out.println("自减开始");
for (int i = 0; i < 3; i++) {
cp.decrement();
System.out.println(cp);
}
System.out.println("清零");
cp.reset();
System.out.println(cp);
}
}
package Task03;
import java.util.Scanner;
public class Test01 {
/**
* 试编写Java代码实现一个计数器类Computer其中包括：
* 域value ：用来保存计数器的当前值；
* 方法increment()： 计数器加一；
* 方法decrement() ：计数器减一；
* 方法reset()：计数器清零。
* 请编写并测试程序。
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in );
System.out.println("请输入一个数字:");
int value = sc.nextInt();
Computer comp = new Computer(value);
comp.increment(value); //comp+1
comp.printInfo();
comp.decrement(value); //comp-1
comp.printInfo();
comp.reset(value); //comp清零
comp.printInfo();
}
}
class Computer { //计数器类
private int count;
public Computer() {
super();
}
public Computer(int count) {
super();
this.count = count;
}
public void increment(int count) {
this.count++;
}
public void decrement(int count) {
this.count--;
}
public void reset(int count) {
this.count = 0;
}
public void printInfo() {
System.out.println(count);
}
}
package demo04;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class Demo01 {
/**
*
2. 要求产生10个随机的字符串,字符串由大小写英文字母和数字组成,每一个字符串
互相不重复,每一个字符串中组成的字符(a-zA-Z0-9)也不相同,每个字符串长度为10;
*/
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
while(set.size()<10){
set.add(generatorStr());
}
for(String s:set){
System.out.println(s);
}
}
//生成长度为10的字符串,每个字符都不同
public static String generatorStr(){
Set<Character> set = new HashSet<Character>();
Character[] chs = new Character[62];
for (int i = 0; i < 26; i++) {
chs[i] = (char) ('a'+i);
}
for (int i = 0; i < 26; i++) {
chs[i+26] = (char) ('A'+i);
}
for (int i = 0; i < 10; i++) {
chs[i+52] = (char) ('0'+i);
}
Random rd = new Random();
while(set.size()<10){
set.add(chs[rd.nextInt(62)]);
}
String s = "";
for(Character c:set){
s += c;
}
return s;
}
}
package Task03;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Test02 {
/**
* 要求产生10个随机的字符串,字符串由大小写英文字母和数字组成,每一个字符串互相不重复,
* 每一个字符串中组成的字符(a-zA-Z0-9)也不相同,每个字符串长度为10;
* @param args
*/
/**
* 分析：
* (1)10个字符串,我们先产生一个10个字符不重复的字符串,
* (2)HashSet去重复
* (3)字符组成是由(a-zA-Z0-9)，字符放到一个容器ArrayList中，随机索引
*/
public static void main(String[] args) {
List<Character> cha = new ArrayList<Character>();
Set<Character> chas = new HashSet<Character>();
Set<String> strs = new HashSet<String>();
for (char i = 'a'; i <= 'z'; i++) { //a ~ z
cha.add(i);
}
for (char i = 'A'; i <= 'Z'; i++) { //A ~ Z
cha.add(i);
}
for (char i = '0'; i <= '9'; i++) { //0 ~ 9
cha.add(i);
}
System.out.println("产生10个随机的字符串：");
while (true) {
chas.clear(); //产生10个字符串后把存储字符的Set清零
while (true) {
//随机下标拿到字符，把字符放进Set中保证了字符是唯一的
int a = (int) (Math.random() * cha.size());
chas.add(cha.get(a));
//当set中有10个数据时，把10个数据打印出来
//然后转成字符串存放到另一个Set中，跳出循环
if (chas.size() == 10) {
for (char c : chas) {
System.out.print(c);
}
String ss = chas.toString();
strs.add(ss);
break;
}
}
System.out.println();
//当存放字符串的set有10个数据时，跳出循环
if (strs.size() == 10) {
break;
}
}
}
}
package demo04;
public class Demo02 {
/**
* 3.编写程序，实现从命令行输入三个数值参数作为三角形的三条边，以此构造一个三角形。
程序应该实现如下功能：
?检查用户输入的命令行参数是否足够，如果不够三个参数，则程序可能产生ArrayIndexOutOfBoundsException异常。
?检查输入的命令行参数是否为数值格式，如果输入的数值参数格式错误，则程序可能产生NumberFormatException异常。
?检查输入的命令行参数中是否有负值，如果有负值，则程序可能产生IllegalArgumentException异常。
?检查输入的命令行参数的三个数值是否能够构造一个三角形，如果不能构造一个三角形，
则程序可能产生InvalidEdgesException异常（InvalidEdgesException异常为用户自定义异常）
*/
public static void main(String[] args) {
try {
float a = Integer.parseInt(args[0]);
float b = Integer.parseInt(args[1]);
float c = Integer.parseInt(args[2]);
if(a<=0 || b<=0 ||c<=0){
throw new IllegalArgumentException("三角形的边长必须为正数");
}
if(a+b<=c || a+c<=b || b+c<=a){
throw new InvalidEdgesException("三角形两边之和大于第三边");
}
System.out.println("三角形的三边:"+a+","+b+","+c);
}catch(ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}catch (NumberFormatException e) {
e.printStackTrace();
}catch(IllegalArgumentException e){
e.printStackTrace();
} catch (InvalidEdgesException e) {
e.printStackTrace();
}
}
}
package demo04;
public class InvalidEdgesException extends Exception{
public InvalidEdgesException(String string) {
super(string);
}
}
package Task03;
public class Test03 {
/**
* 编写程序，实现从命令行输入三个数值参数作为三角形的三条边，以此构造一个三角形。
* 程序应该实现如下功能：
* 检查用户输入的命令行参数是否足够，如果不够三个参数，则程序可能产生ArrayIndexOutOfBoundsException异常。
* 检查输入的命令行参数是否为数值格式，如果输入的数值参数格式错误，则程序可能产生NumberFormatException异常。
* 检查输入的命令行参数中是否有负值或0，如果有负值或0，则程序可能产生IllegalArgumentException异常。
* 检查输入的命令行参数的三个数值是否能够构造一个三角形，如果不能构造一个三角形，则程序可能产生InvalidEdgesException异常（InvalidEdgesException异常为用户自定义异常）。
*/
public static void main(String[] args) throws InvailEdgesException {
try {
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);
int c = Integer.parseInt(args[2]);
if (args.length != 3) {
throw new ArrayIndexOutOfBoundsException("请输入三个参数");
}
if (a <= 0 || b <= 0 || c <= 0) {
throw new IllegalArgumentException("三角形的边长必须大于 0");
}
if (a >= b + c || b >= a + c || c >= a + b) {
throw new InvailEdgesException("三角形的两边之和必须大于第三边");
}
System.out.println(a + " " + b + " " + c + " " + "这三条边可以构成三角形");
} catch (NumberFormatException e) { //Exception e 父类
e.printStackTrace();
}catch(ArrayIndexOutOfBoundsException e){
e.printStackTrace();
}catch(IllegalArgumentException e){
e.printStackTrace();
}catch( InvailEdgesException e){
e.printStackTrace();
}
}
}
class InvailEdgesException extends Exception {
public InvailEdgesException(String message) {
super(message);
}
}
/* for (int i = 0; i < args.length; i++) {
* try {
* Integer.valueOf(args[i]);
* } catch (Exception e) {
* throw new NumberFormatException("请输入数值");
* }
* }
**/
package demo04;
import java.util.Calendar;
public class Demo03 {
/**
* 中国式日历
*/
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, 2018);
System.out.println("\t\t\t2018年日历\t\t\t");
for (int i = 0; i < 12; i++) {
System.out.println("*********"+(i+1)+"月份日历***********");
cal.set(Calendar.MONTH, i);
generatorCal(cal);
}
}
private static void generatorCal(Calendar cal) {
cal.set(Calendar.DAY_OF_MONTH, 1);
int start = cal.get(Calendar.DAY_OF_WEEK);
start = start-1==0?7:start-1;
// 2 3 4 5 6 7 1
// 1 2 3 4 5 6 7
System.out.println("一\t二\t三\t四\t五\t六\t日");
for (int i = 1; i <=42+7; i++) {
if(i>=start){
System.out.print(cal.get(Calendar.DATE)+"\t");
}else{
System.out.print("\t");
continue;
}
if(i%7==0){
System.out.println();
}
if(cal.get(Calendar.DAY_OF_MONTH) == cal.getActualMaximum(Calendar.DAY_OF_MONTH)){
break;
}
cal.add(Calendar.DATE,1);
}
System.out.println();
}
}
package Task03;
import java.util.Calendar;
public class Test04 {
public static void main(String[] args) {
// 打印2018年日历
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, 2018);
System.out.println("\t\t\t2018年日历\t\t\t");
for (int i = 0; i < 12; i++) {
System.out.println("**********************"+(i+1)+"月份************************");
cal.set(Calendar.MONTH, i);
generateCal(cal);
}
}
private static void generateCal(Calendar cal) {
// 将时间移动到本月的第一天
cal.set(Calendar.DAY_OF_MONTH, 1);
// 本月第一天在所在周是第几天
int start = cal.get(Calendar.DAY_OF_WEEK);
if (start == 1) { //第一天換成星期一，其他往后退一步
start = 7;
} else
start -= 1;
// 打印日历头
System.out.println("一\t二\t三\t四\t五\t六\t日");
for (int i = 1; i <= 7 * 6; i++) {
if (i < start) {
System.out.print("\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);
}
System.out.println();
}
}
package demo04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class Demo04 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入一个字符串:");
String str = sc.nextLine();
Map<Character,Integer> map = new HashMap<Character,Integer>();
char[] chs = str.toCharArray();
for(Character c:chs){
Integer num = map.get(c);
if(num==null){
//第一次遇到这个字符
map.put(c, 1);
}else{
//重复遇到这个字符
map.put(c,num+1);
}
}
System.out.println(map);
//按照字符出现的次数排序
Set<Entry<Character, Integer>> set = map.entrySet();
List<Entry<Character, Integer>> list = new ArrayList<Entry<Character, Integer>>(set);
Collections.sort(list, new Comparator<Entry<Character, Integer>>(){
@Override
public int compare(Entry<Character, Integer> o1, Entry<Character, Integer> o2) {
return -(o1.getValue() - o2.getValue());
}
});
for(Entry<Character, Integer> ey:list){
System.out.println(ey.getKey()+":"+ey.getValue());
}
}
}
package Task03;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class Test05 {
/**
* 统计字符个数，再按字符个数降序排列信息
*/
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中
// 'y'-- 2 'o'--2 'u'--3 ' '---4
Map<Character,Integer> map = new HashMap<Character,Integer>();
//遍历数组chs
//['y','o','u',' ','c','a',...]
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));
}
System.out.println("-------------------------------------");
//排序
//将map ---> list
Set<Entry<Character, Integer>> set = map.entrySet();
List<Entry<Character, Integer>> list = new ArrayList<Entry<Character, Integer>>(set);
Collections.sort(list, new NumComparator());
for(Entry<Character, Integer> ey:list){
System.out.println(ey.getKey()+":"+ey.getValue());
}
}
}
class NumComparator implements Comparator<Entry<Character, Integer>>{
public int compare(Entry<Character, Integer> ey1, Entry<Character, Integer> ey2) {
// 'y' - 2
return ey2.getValue() - ey1.getValue();
}
}