package xiaosai; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input=new Scanner(System.in); int a=input.nextInt(); int b=input.nextInt(); int c=input.nextInt(); for(int i=1;i<1000;i++) { if(i%a==0&&i%b==0&&i%c==0) //最小的值应该满足同时可以整除三个数字 { System.out.println(i); break; } } } }
import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt();//输入数组的长度 int[] a = new int[n];//定义一个n长度的数组a for(int i=0;i<n;i++) { a[i] = in.nextInt(); //一位一位输入内容 } int m = in.nextInt();//定义找几次 int[] ans = new int[m];//按照m定义长度数组ans for(int i=0;i<m;i++)//找几次就循环几次 { int l = in.nextInt();//输入要选的左边值 int r = in.nextInt();//输入要选的右边值 int k = in.nextInt();//输入要选的第k大值 int[] b = new int[r-l+1];//定义一个截取范围的数组b for(int j=0;j<r-l+1;j++)//从0到最大值赋值 { b[j]=a[j+l-1];//依次将对应的值放入b数组中 } Arrays.sort(b);//一定要记得排序(输入的数字不一定按顺序排列) ans[i]=b[r-l+1-k];//把那个最k大值放入ans数组值中 } for(int i=0;i<m;i++) { System.out.println(ans[i]);//依次输出的就是找几次的对应的答案 }
package xiaosai; import java.util.Scanner; import java.math.*; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int n = input.nextInt(); BigDecimal sum = BigDecimal.ONE;//使用BigDecimal类型存放答案 for(int i = 1; i <= n; i++) { sum = sum.multiply(BigDecimal.valueOf(i));//使用乘法(不使用递归方法！) }
String S = sum.toString(); //将结果转化为字符串 for(int i = S.length()-1; i >= 0; i--) { if(S.charAt(i) != '0')//遇到第一个非0的数字输出 { System.out.println(S.charAt(i)); break; } } } }
publicclassSaleTicketDemo3{ publicstaticvoidmain(String[] args){ TicketSaleThread t1 = new TicketSaleThread(); TicketSaleThread t2 = new TicketSaleThread(); TicketSaleThread t3 = new TicketSaleThread();
在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
class Account{ //账户 private double balance;//余额 //set和get方法 public double getBalance() { return balance; } public void setBalance(double balance) { this.balance = balance; } //存款方法 --要写成同步方法 public synchronized void deposit(double money){ //非静态方法默认是this 因为account是唯一的 所以可以 this.balance+=money; System.out.println(Thread.currentThread().getName()+"充了1000元,现在余额是:"+this.getBalance()); } }
class Customer extends Thread{ //有一个账户对象 Account account; //有参构造器 public Customer(Account account){ this.account=account; } public Customer(Account account,String name){ super(name); this.account=account; } @Override public void run(){ //存钱的操作要放入run方法 for(int i=0;i<3;i++){ account.deposit(1000); } }
}
public class AccountTest { public static void main(String[] args) { //创建账户类对象 Account account = new Account(); Customer customer1 = new Customer(account,"甲"); Customer customer2 = new Customer(account,"乙"); customer1.start(); customer2.start(); } }
publicclassTestDeadLock{ publicstaticvoidmain(String[] args){ Object g = new Object(); Object m = new Object(); Owner s = new Owner(g,m); Customer c = new Customer(g,m); new Thread(s).start(); new Thread(c).start(); } } classOwnerimplementsRunnable{ private Object goods; private Object money;
wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
/* * 创建多线程的方式三：实现Callable （jdk5.0新增的） */ //1.创建一个实现Callable的实现类 classNumThreadimplementsCallable{ //2.实现call方法，将此线程需要执行的操作声明在call()中 @Override public Object call()throws Exception { int sum = 0; for (int i = 1; i <= 100; i++) { if (i % 2 == 0) { System.out.println(i); sum += i; } } return sum; } }
publicclassCallableTest{ publicstaticvoidmain(String[] args){ //3.创建Callable接口实现类的对象 NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start() new Thread(futureTask).start();
特有(首尾操作)的方法： 第一组： void addFirst(E e); void addLast(E e); 第二组(返回移除的元素)： E removeFirst(); E removeLast(); 第三组(返回特定的元素)： E getFirst(); E getLast(); 第四组： E pop(); //弹出,删除集合中的第一个元素 void push(E e);//推入,往集合中增加一个元素
hashCode方法的源码: public native int hashCode(); native：代表该方法调用的是本地操作系统的方法。
1 2 3 4 5 6 7 8 9 10 11
public class Main extends Object{ //写继承Object类更加明显看出是Object类的方法 public static void main(String[] args) { Main i=new Main(); int a=i.hashCode(); //调用方法 System.out.println(a); //2018699554(逻辑地址) Main j=new Main(); int b=j.hashCode(); //调用方法 System.out.println(b); //1311053135(逻辑地址) } }
public class Main extends Object { public static void main(String[] args) { Main i=new Main(); int a=i.hashCode(); System.out.println(a); //2018699554 Main j=new Main(); int b=j.hashCode(); //1311053135 System.out.println(b); /*toString方法的源码： return getClass().getName()+"@"+Integer.toHexString(hashCode()); //“类名@十六进制数字” */ System.out.println(i); //Main@7852e922 System.out.println(j); //Main@4e25154f } }
import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Main { public static void main(String[] args) { //定义一个集合 Collection<String> its=new ArrayList<String>(); its.add("alibaba"); its.add("tenxun"); its.add("itcast"); //出现了小写的“itcast”字符串 its.add("baidu"); its.add("sohu"); its.add("netease"); //迭代器遍历集合 //获取集合的迭代器对象 Iterator<String> it =its.iterator(); //循环遍历 while(it.hasNext()) { String itname=it.next(); if("itcast".equals(itname)) //避免问题(常量在前面就不会有null的情况) { its.add("ITCAST"); //通过集合去添加 } } } }
代码结果： Exception in thread “main” java.util.ConcurrentModificationException(出现异常) at java.util.ArrayList$Itr.checkForComodification(Unknown Source) at java.util.ArrayList$Itr.next(Unknown Source) at Main.main(Main.java:21)
代码结果分析： 执行demo01()方法： 不使用泛型的话，编译时期没有错误，但是执行就会报错。 Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at Main.demo01(Main.java:17) at Main.main(Main.java:4)
public class Main { public static void main(String[] args) { //创建一个Person Person p=new Person(); p.setAaa("123"); //创建一个Person<E> Person<String> pp=new Person<String>; pp.setAaa("ASD"); //可以设置String的
import java.util.Scanner; public class Collection { public static void main(String[] args){ Scanner input=new Scanner(System.in); int n=input.nextInt(); int[] a=new int[n]; a[1]=a[2]=1; int m=feibo(n)%10007; //最终的值除以10007求余数 System.out.println(m);
}
public static int feibo(int n){ if(n==1||n==2) //前两个的值需要给出，才能依次算出后面的值 return 1; else return (feibo(n-1)+feibo(n-2)); //递归主要思路 } }
import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input=new Scanner(System.in); int n=input.nextInt(); int m=input.nextInt(); int[][] a=new int[n][m]; char[] b={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}; //用下标方便的放入相对于的值
for(int i=0;i<n;i++) { for(int j=0;j<m;j++) { int c=i-j; //求下标之差（可能有负数） int d=(Math.abs(c))%26; //求下标之差的绝对值（如果大于26行就需要求余） System.out.print(b[d]); } System.out.println(); } } }
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input=new Scanner(System.in); long n=input.nextLong(); //定义了一个long型的数字 System.out.printf(Long.toHexString(n).toUpperCase()); //转换为十六进制数并且为大写字母
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input=new Scanner(System.in); String num=input.nextLine(); Long da=Long.parseLong(num,16); System.out.println(da); } }
import java.util.Scanner; public class ReflectTest { public static void main(String[] args) { //用a和b的字符串数组存放时刻时间 String a[]={"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty"}; String b[]={"twenty","thirty","forty","fifty"};
//设置h和m为输入的分钟和小时数 Scanner input=new Scanner(System.in); int h=input.nextInt(); int m=input.nextInt(); if(m==0)//如果分钟为0的话就是只有小时 后面加o'clock { switch(h/10)//判断输出 { case 0:System.out.println(a[h%10]+" "+"o'clock");break; //直接在a数组找 case 1:System.out.println(a[h]+" "+" "+"o'clock");break;//直接在a数组找 case 2:System.out.println(b[0]+" "+a[h%10]+" "+"o'clock");break; //twenty+个位的 } } else { switch(h/10)//和if条件里面的相同 { case 0:System.out.print(a[h%10]);break; case 1:System.out.print(a[h]);break; case 2:System.out.print(b[0]+" "+a[h%10]);break; } switch(m/10) { case 0:System.out.print(" "+a[m%10]);break; case 1:System.out.print(" "+a[m]);break;//直接在a数组找 case 2:System.out.print(" "+b[0]+" "+a[m%10]);break; case 3:System.out.print(" "+b[1]+" "+a[m%10]);break; case 4:System.out.print(" "+b[2]+" "+a[m%10]);break; case 5:System.out.print(" "+b[3]+" "+a[m%10]);break; } } } }
import java.util.*; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s=input.next();//用字符串输入15位身份证 char[] a=s.toCharArray();//转成字符数组 int[] b=new int[16];//用16位去表示结果(17-1917只把1编程191) for(int i=0;i<a.length;i++) { b[i]=a[i];//把每一位传给int型数组b b[i]=b[i]-48;//必须减48才能从字符转为数字的0/1...9 } b[6]=b[6]+190;//将第一位x直接变成19x b[15]=(b[0]*7)+(b[1]*9)+(b[2]*10)+(b[3]*5)+(b[4]*8)+(b[5]*4)+2+9+((b[6]%10)*6)+(b[7]*3)+(b[8]*7)+(b[9]*9)+(b[10]*10)+(b[11]*5)+(b[12]*8)+(b[13]*4)+(b[14]*2);//注意我现在的只有16位(每一位对应的乘要变化) b[15]=b[15]%11;//计算出来之后对11取余 switch (b[15])//依次判断出最后一位是什么 { case 0:b[15]=1;break; case 1:b[15]=0;break; case 2:b[15]=-1;break; //先用-1代替x case 3:b[15]=9;break; case 4:b[15]=8;break; case 5:b[15]=7;break; case 6:b[15]=6;break; case 7:b[15]=5;break; case 8:b[15]=4;break; case 9:b[15]=3;break; case 10:b[15]=2;break; }
十七、不同单词个数统计(split()方法) 问题描述 编写一个程序，输入一个句子，然后统计出这个句子当中不同的单词个数。例如：对于句子“one little two little three little boys”，总共有5个不同的单词：one, little, two, three, boys。 说明：（1）由于句子当中包含有空格，所以应该用gets函数来输入这个句子；（2）输入的句子当中只包含英文字符和空格，单词之间用一个空格隔开；（3）不用考虑单词的大小写，假设输入的都是小写字符；（4）句子长度不超过100个字符。 输入格式：输入只有一行，即一个英文句子。 输出格式：输出只有一行，是一个整数，表示句子中不同单词的个数。 输入输出样例 样例输入 one little two little three little boys 样例输出 5
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s = input.nextLine();//用nextLine格式输入要判断的字符串 String[] a = s.split(" ");//用split方法得到每个单词 int sum = 0;//计数 for (int i = 0; i < a.length; i++) { for (int j = i + 1; j < a.length; j++)//二重循环依次判断 { if (a[i].equals(a[j])) { a[j] = " ";//将相同的其中一个单词换成空格 } } } for (int i = 0; i < a.length; i++) { if(a[i]!=" ") sum++;//输出不是空格的位置的单词数量 } System.out.println(sum); } }
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s1 = input.next();//输入要判断的字符串s1 String[] a = s1.split("");//利用split方法隔成字符串数组a String[] b = new String[a.length];//创建一个字符串数组b int j = 0; for (int i = a.length - 1; i >= 0; i--) { b[j++] = a[i]; //反序把a输入到b里面 }
StringBuffer s2 = new StringBuffer();//使用StringBuffer 创建一个字符串s2 for (String i : b) { s2.append(i);//增强for循环将字符串数组转成字符串 }
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s = input.next(); System.out.println("Hex: Ox" + s);
Long shi = Long.parseLong(s, 16);//转成十进制 System.out.println("Decimal: " + shi);
String ba = Integer.toOctalString(Integer.valueOf(s, 16));//转成8进制 char[] a = ba.toCharArray(); int cha = 4 - a.length; if (cha == 0) { System.out.println("Octal: " +ba); } if (cha == 1) { System.out.println("Octal: 0" +ba); } if (cha == 2) { System.out.println("Octal: 00" +ba); } if (cha == 3) { System.out.println("Octal: 000" +ba); }
