package bag;import java.util.Vector;public class aaa{public static void main(String [] args){Vector myVector=new Vector();//myVector.addElement(Integer.valueOf(1));//addchar ch = 'A';myVector.insertElementAt(Character.valueOf(ch), 0);//insertmyVector.setElementAt(Integer.valueOf(2),1);//set A at place,(replace)myVector.removeElement(Integer.valueOf(2));//remove IntegermyVector.removeElementAt(0);//remove at:imyVector.addElement(Integer.valueOf(3));//addmyVector.removeAllElements();//格式化myVector.addElement(Integer.valueOf(4));//addmyVector.addElement(Integer.valueOf(5));//addmyVector.addElement(Integer.valueOf(6));//add/*for (int i:myVector-+) {System.out.println("集合元素为"+i);}*/if(myVector.contains(Integer.valueOf(4))) {int Int=(int)myVector.elementAt(0);//找第n个数System.out.println(Int);System.out.println(myVector.indexOf(Integer.valueOf(4),0));//向后找数System.out.println(myVector.lastIndexOf(Integer.valueOf(5),2));//向前找数}else {System.out.print("false");}}}

class MyClass {    private int value;    public MyClass(int value) {        this.value = value;    }    //getter方法    public int getValue() {        return value;    }    // setter方法    public  void setValue(int value) {//void不返回值，因为是设置值         this.value = value;    }}public class bbb {public static void main(String [] args) {MyClass myObject = new MyClass(5);//加密值 int value = myObject.getValue(); // 获取加密值myObject.setValue(10); // 设置值int Value=myObject.getValue();System.out.println(value);System.out.println(Value);}}

class Parent {    int x = 10;    public void print() {        System.out.println("Parent's print method");    }}class Child extends Parent {    int x = 20;    public void print() {        System.out.println("Child's print method");    }}class aaa{public static void main(String[] args) {       Parent p = new Child();/*Chlid中有Parent的域？因为子类只是隐藏？*/       System.out.println(p.x);       p.print();//p是从Child那赋值来的，print方法已经被覆盖               if (p instanceof Child) {        ((Child) p).print2();        }       /*在代码p.print2();中会出现错误，原因在于变量p的类型是Parent。       虽然它实际指向的对象是Child类型（通过new Child()创建的），       但在编译阶段，编译器只会根据变量声明的类型（也就是Parent类型）来检查能够调用的方法。       由于Parent类中并没有定义print2这个方法，所以编译器认为通过p调用print2是不合法的操作，       从而报错。如果想要调用print2方法，需要先将p进行向下转型（前提是确定实际对象是Child类型）*/}}

import java.util.*; import java.io.*; public class Main{ public static void main(String[] args) throws IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); String[] in = bf.readLine().split(";");//分隔字符 int x = 0; int y...

import java.io.*;   public class Main {       public static void  main(String[] args)throws IOException{            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));            //Scanner br=new Scanner(System.in);            String character=null;            while((character=br.readLine())!=null){                byte[] byteArray =character.getBytes();                //当character为char型时，用Character.toString().getBytes()方法                //当character为int、string等等类型时，用String.valueOf()方法                for (byte b : byteArray) {                    String binaryByte = Integer.toBinaryString(b & 0xff);//0和1取0，1和1取1                    /*它的作用是将一个整数与 0xff 进行按位与操作，然后将结果转换为二进制字符串并赋值给变量 binaryByte。其中，“&” 是 按位与 运算符，0xff 是十六进制表示的 255，相当于二进制的 11111111。对0xff进行按位与操作——这样做通常是为了获取一个字节（8 位）的二进制表示，因为在 Java 中整数通常是 32 位或 64 位的，通过与 0xff 进行按位与操作可以只保留原数“二进制数的”低 8 位的值，并将其转换为二进制字符串表示*/                    System.out.println(binaryByte);                }            }                  }   }

import java.util.Scanner;import java.math.*;   public class Main {       public static boolean isPrime(int n) {           if (n                return false;           }           double m=Math.sqrt(n);           for (int i = 2; i                if (n % i == 0) {                   return false;               }           }           return true;       }       public static void main(String[] args) {           Scanner sca=new Scanner(System.in);           int num = sca.nextInt();           boolean result = isPrime(num);           if (result) {               System.out.println(num + "是素数");           } else {               System.out.println(num + "不是素数");           }       }   }

import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int num = scanner.nextInt(); scanner.close();// Scanner 对象从控制台读取输入后，及时关闭它可以避免资源泄漏 int count = 0; while (num!= 0) { ...

import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt();//第一个数为int型的 scanner.nextLine(); // 消耗掉换行符，避免影响后续输入读取 String[] strings = ...

import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); String str=in.nextLine(); String[] words =str.split(" "); int n=words.length; //for(int i=n-1;i>=0;){ // Sys...

import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); boolean allLowerCase = true;//布尔值 for (char c : input.toCharArray()) { if (Character.isUpperC...

import java.util.*; // 注意类名必须为 Main, 不要有任何 package xxx 信息 public class Main { public static void main(String[] args) { Scanner a=new Scanner(System.in); String str=a.next(); StringBuilder sb=new StringBuilder(str);//可变字符串类 System.out.println(sb.reverse());//对象（如列...

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。示例：输入：s = 7, nums = [2,3,1,2,4,3]输出：2解释：子数组 [4,3] 是该条件下的长度最小的子数组。class Solution {    // 滑动窗口(双指针)    public int minSubArrayLen(int s, int[] nums) {        int left = 0;        int sum = 0;        int result = Integer.MAX_VALUE;        for (int right = 0; right             sum += nums[right]; while (sum >= s) {                result = Math.min(result, right - left + 1);                sum -= nums[left++];            }        }        return result == Integer.MAX_VALUE ? 0 : result;    }}

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。示例 1：输入：nums = [-4,-1,0,3,10]输出：[0,1,9,16,100]解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]class Solution {    public int[] sortedSquares(int[] nums) {        int right = nums.length - 1;        int left = 0;        int[] result = new int[nums.length];        int index = result.length - 1;        while (left  if (nums[left] * nums[left] > nums[right] * nums[right]) {                // 正数的相对位置是不变的， 需要调整的是负数平方后的相对位置                result[index--] = nums[left] * nums[left];                ++left;            } else {                result[index--] = nums[right] * nums[right];                --right;            }        }        return result;    }}

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。// 快慢指针class Solution {    public int removeElement(int[] nums, int val) {        int slowIndex = 0;        for (int fastIndex = 0; fastIndex             if (nums[fastIndex] != val) {                nums[slowIndex] = nums[fastIndex];                slowIndex++;            }        }        return slowIndex;    }}//相向双指针法class Solution {    public int removeElement(int[] nums, int val) {        int left = 0;        int right = nums.length - 1; while(right >= 0 && nums[right] == val) right--; //将right移到从右数第一个值不为val的位置        while(left             if(nums[left] == val) { //left位置的元素需要移除                //将right位置的元素移到left（覆盖），right位置移除                nums[left] = nums[right];                right--;            }            left++; while(right >= 0 && nums[right] == val) right--;        }        return left;    }}