java基础部分典型代码

最新推荐文章于 2023-10-27 10:20:33 发布

你的小天使

最新推荐文章于 2023-10-27 10:20:33 发布

阅读量594

点赞数 2

本文链接：https://blog.csdn.net/qq_43141904/article/details/89408430

版权

1.二分查找

public class ArrayDemo2 {
    public static void main(String[] args) {
        //二分查找
        int[] arr={10,20,30,50,60,70,80};
        int index=findIndex(arr,50);
        System.out.println(index);

    }

    private static int findIndex(int[] arr, int ele) {
        //定义三个变量
        int minIndex=0;
        int maxIndex=arr.length-1;
        int centerIndex=(minIndex+maxIndex)/2;
        while (minIndex<=maxIndex){
            if (ele == arr[centerIndex]) {
                return centerIndex;
                //如果要查的元素大于中间元素,动最小索引
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
                //如果要查的元素小于中间元素,动最大索引
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            }
            //重新计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }

        return -1;
    }
}

2.有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

    分析:1.我要把这个字符串转成数组,排序数组,再把排序好的数组转成字符串

public class MyDemo5 {
    public static void main(String[] args) {
//        A:
//        案例演示:
//        需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
//        分析:1.我要把这个字符串转成数组,排序数组,再把排序好的数组转成字符传
        String str="91 27 46 38 50";
        //截取字符串
        String[] split = str.split(" ");
        //自己定义一个int类型的数组
        int[] arr=new int[split.length];
        //遍历字符串数组,把每个元素存到int数组
        for (int i = 0; i <split.length ; i++) {
            arr[i]=Integer.parseInt(split[i]);
       }
       //排序数组元素
        Arrays.sort(arr);
        //遍历int数组,拼串
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<arr.length;i++){
            sb.append(arr[i]).append(" ");
        }
        System.out.println(sb.toString().trim());

        //结果:"27 38 46 50 91"
    }
}

3.获取下面这个字符串中由三个字符组成的单词

    //da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?

public class Demo6 {
    public static void main(String[] args) {
        //需求：获取下面这个字符串中由三个字符组成的单词
        //da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?
        //[a-z]{3}
        String s="da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?";
        Pattern p = Pattern.compile("\\b[a-z]{3}\\b");
        Matcher  m= p.matcher(s);
        while(m.find()){
            String group = m.group();
            System.out.println(group);
        }

    }
}

4.日期格式

public class MyDemo4 {
    public static void main(String[] args) {
        SimpleDateFormat s= new SimpleDateFormat();
        String format = s.format(new Date());
        System.out.println(format);


        SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss E z");
        String format1 = s2.format(new Date());
        System.out.println(format1);
    }
}

4.计算来到世界的时间

public class MyDemo3 {
    public static void main(String[] args) throws ParseException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请录入你的生日 格式为 2018-10-23");
        String s = scanner.nextLine();
        long start = DateUtils.changeDate(s, "yyyy-MM-dd").getTime();
        long now = System.currentTimeMillis();
        System.out.println((now-start)/1000/60/60/24/365);
    }
}

5.需求：键盘录入任意一个年份，获取任意一年的二月有多少天

	分析:

```
 a: 键盘录入一个年份
```
```
 b: 创建一个Calendar对象
```

 c: 把这个Calendar的时间设置为a中录入的年的3月1号    注意2表示3月

```
 d: 向前推算一天
```
```
 e: 获取月中的天
```
```
 f: 输出
```

 // 创建一个Scanner对象
		Scanner sc = new Scanner(System.in) ;
		
		// 友情提示
		System.out.println("请您输入一个年: ");
		
		// 获取键盘录入数据
		int year = sc.nextInt() ;
		
		// 创建Calendar对象
		Calendar calendar = Calendar.getInstance() ;
		
		// 把这个Calendar的时间设置为a中录入的年的3月1号
		calendar.set(year, 2 , 1) ;
		
		// 向前推算一天
		calendar.add(Calendar.DAY_OF_MONTH, -1) ;
		
		// 获取
		int day = calendar.get(Calendar.DAY_OF_MONTH) ;
	
		// 输出
		System.out.println(day);

6.需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)

    //思路：创建新集合方式

     public class MyDemo1 {
 public static void main(String[] args) {
     //案例演示
     //需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
     //思路：创建新集合方式
     ArrayList list  = new ArrayList();
     list.add("女施主");
     list.add("我给你");
     list.add("送茶来了");
     list.add("御弟哥哥");
     list.add("御弟哥哥");

     ArrayList list1 = new ArrayList();
     for(int i=0;i<list.size();i++){
         String  o =(String ) list.get(i);
         if(!list1.contains(o)){
             list1.add(o);
         }

     }
     System.out.println(list1);

 }
}

7.Vector中的一些方法

public class MyDemo2 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);


        Vector vector2 = new Vector();
        vector2.addElement(100);
        vector2.addElement(200);
        vector2.addElement(300);
        vector2.addElement(500);

        Enumeration elements = vector.elements();
        while(elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }
        //对比两个集合中的元素是否一样
        boolean equals = vector.equals(vector2);
        System.out.println(equals);
        Object o = vector2.firstElement();
        System.out.println(o);
        vector2.removeElementAt(vector2.size()-1);
        System.out.println(vector2);

    }
}
输出：
100
200
300
false
100
[100, 200, 300]

8.可变参数（普通方法与集合中可变参数的设置）

public class MyDemo2 {
    public static void main(String[] args) {
        int r = sum(2, 3);
        int r1 = sum(2, 3, 4);
        int r2 = sum(2, 3, 5, 6);
        System.out.println(r);
        System.out.println(r1);
        System.out.println(r2);
        //asList(100, 200, 3, 20, 90) 把多个元素装到集合里面去
        //通过asList()这个方法转换过来的集合,此集合不能再增删元素
        List<Integer> integers = Arrays.asList(100, 200, 3, 20, 90);
        //integers.remove(0); 报错
        //integers.add(900);报错
        Integer integer = integers.get(0);//可以获取
        System.out.println(integer);
        System.out.println(integers);


    }
    

    //可变参数:数据类型...  参数名
    //可变参数实际上是个数组
    //可变参数写在最后
    //C:注意事项：
    //a:这里的变量其实是一个数组
    //b:如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个


    private static int sum(int b, int... a) {
        // System.out.println(a.length);
        int sum = 0 + b;
        for (int ele : a) {
            sum += ele;
        }
        return sum;
    }

}

9.Map集合的遍历

public class MyDemo1 {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("zqq","gdgfdg");
        map.put("ggg","nnmzdhgf");

        System.out.println(map);
        //map.remove("zqq");
       // System.out.println(map);

        //通过键找值来遍历
        Set<String> strings = map.keySet();
        for(String key:strings){
            String value = map.get(key);
            System.out.println(key+"**"+value);
        }

        //遍历键值对
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry<String,String> entry:entries){
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"&&"+value);
        }

    }
}
输出：
{ggg=nnmzdhgf, zqq=gdgfdg}
ggg**nnmzdhgf
zqq**gdgfdg
ggg&&nnmzdhgf
zqq&&gdgfdg

10.TreeMap集合（自定义数据类型中要实现Compareble接口的compareTo()方法）

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student s) {
        //System.out.println(this+"==="+s);
        //需求:按照年龄大小来排序学生
        //年龄一样了,不能说明是同一个对象,我们还得比较姓名是否一样
        int flag=0;
        int num=this.age-s.getAge();
        int num2=num==0?this.name.compareTo(s.name):num;
        return -num2;
    }
}
public class TreeSetDemo3 {
    public static void main(String[] args) {
        //自然排序:采用空参构造,那么使用的就是自然排序
        //如果你使用的是自然排序,那么对排序的元素有要求,
        // 什么要求:要求元素必须实现Compareble接口,重写此接口中的 compareTo() 方法
        //根据此方法的反回值的正负0 来决定元素在二叉树中 是往左边放 还是右边放,还是不往里面放
        //需求:按照年龄大小来排序学生
        Student s1 = new Student("穆念慈aa", 20);
        Student s2 = new Student("阿紫cccc", 21);
        Student s3 = new Student("阿朱aaaaa", 23);
        Student s4 = new Student("秦红棉ddd", 19);
        Student s5 = new Student("黄蓉ddddd", 27);
        Student s6 = new Student("郭芙ddd", 23);
        Student s7 = new Student("郭襄", 20);
        Student s8 = new Student("李莫愁aaa", 20);
        Student s9 = new Student("小龙女cccccccccc", 20);
        Student s10 = new Student("小龙女3ffff", 20);
        Student s11 = new Student("穆念慈", 22);
        Student s12 = new Student("穆念慈", 22);
        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
        treeSet.add(s7);
        treeSet.add(s8);
        treeSet.add(s9);
        treeSet.add(s10);
        treeSet.add(s11);
        treeSet.add(s12);
        for (Student student : treeSet) {
            System.out.println(student.getName()+"=="+student.getAge());
        }
    }
}

输出：
黄蓉ddddd==27
阿朱aaaaa==23
郭芙ddd==23
穆念慈==22
阿紫cccc==21
郭襄==20
穆念慈aa==20
李莫愁aaa==20
小龙女cccccccccc==20
小龙女3ffff==20
秦红棉ddd==19

11.匿名内部类和lambda表达式的使用

public class TreeSetDemo3 {
    public static void main(String[] args) {
        //比较器排序:采用的是有参构造,参数要一个比较器
        //TreeSet(Comparator < ? super E > comparator)
        //构造一个新的空 TreeSet，它根据指定比较器进行排序。
        //java.util
        //接口 Comparator<T >
        //int compare (T o1, T o2)
        //比较用来排序的两个参数。
        //采用匿名内部类的方式来传一个比较器
//        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
//            @Override
//            public int compare(Student s1, Student s2) {
//                int num=s1.getName().length()-s2.getName().length();
//                int num2=num==0?s1.getName().compareTo(s2.getName()):num;
//                int num3=num2==0?s1.getAge()-s2.getAge():num2;
//                return num3;
//            }
//        });
        //Lambda 表达式 JDK1.8的新特性
        Comparator<Student> com=(s1, s2) -> {
            int num = s1.getName().length() - s2.getName().length();
            int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
            int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
            return num3;
        };
        TreeSet<Student> treeSet2 = new TreeSet<>(com);
        Student s1 = new Student("穆念慈aa", 20);
        Student s2 = new Student("阿紫cccc", 21);
        Student s3 = new Student("阿朱aaaaa", 23);
        Student s4 = new Student("秦红棉ddd", 19);
        Student s5 = new Student("黄蓉ddddd", 27);
        Student s6 = new Student("郭芙ddd", 23);
        Student s7 = new Student("郭襄", 20);
        Student s8 = new Student("李莫愁aaa", 20);
        Student s9 = new Student("小龙女cccccccccc", 20);
        Student s10 = new Student("小龙女3ffff", 20);
        Student s11 = new Student("穆念慈", 22);
        Student s12 = new Student("穆念慈", 23);
        treeSet2.add(s1);
        treeSet2.add(s2);
        treeSet2.add(s3);
        treeSet2.add(s4);
        treeSet2.add(s5);
        treeSet2.add(s6);
        treeSet2.add(s7);
        treeSet2.add(s8);
        treeSet2.add(s9);
        treeSet2.add(s10);
        treeSet2.add(s11);
        treeSet2.add(s12);
        for (Student student : treeSet2) {
            System.out.println(student.getName()+"=="+student.getAge());
        }
    }
}

12.

public class MyDemo2 {

    public static void main(String[] args) {
        //1.数组排序
        Integer[] a={99,2,3,89};
        Arrays.sort(a,(s1,s2)-> {
            return s1-s2;
        });
        String string = Arrays.toString(a);
        System.out.println(string);

        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        //2.集合排序
        List<Integer> list=Arrays.asList(3,5,77,555);
        list.sort((c,b)->{
            return c-b;
        });
        System.out.println(list);
    }
}

13.输入你想要的类型的数据，如果输入的不正确，就继续输入，直到输入正确的类型为止（运用try{}catch(){}语句）

public class ExceptionDemo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        while (true) {
            try {
                int i = sc.nextInt();
                System.out.println(i);
                break;
            }catch (Exception e){
                //e.printStackTrace();
                sc = new Scanner(System.in);
                System.out.println("你输入的类型不正确");
            }
        }
    }
}

14.自定义异常

public class MyExcepiton extends RuntimeException{
    public MyExcepiton(String name) {
       super(name);
    }//自定义 异常
}

15.目录和文件的简单创建

public class FileDemo{
    public static void main(String[] args) throws IOException {
        //创建多级目录
        File file = new File("F:\\ceshi\\zqq");
        boolean mkdirs = file.mkdirs();
        if(mkdirs){
            System.out.println("创建多级目录成功");
        }else{
            System.out.println("创建多级目录失败");
        }
        //创建文件
        File file1 = new File("F:\\", "cesshi.txt");
        boolean fb = file1.createNewFile();
        if(fb){
            System.out.println("创建文件成功");
        }else{
            System.out.println("创建文件失败");
        }
//重命名时:如果两个文件不在同一目录下,那就是剪切并重命名
 //       File file = new File("d.txt");
 //       boolean b = file.renameTo(new File("E:\\e.txt"));
 //       System.out.println(b);

    }
}

删除只能删除空目录，不能删除多级目录
//判断功能
//public boolean isDirectory ():判断是否是目录
//public boolean isFile ():判断是否是文件
//public boolean exists ():判断是否存在
//public boolean canRead ():判断是否可读
//public boolean canWrite ():判断是否可写
//public boolean isHidden ():判断是否隐藏
// boolean canExecute () 判断此文件是否是可执行文件
//获取功能
//public String getAbsolutePath ()：获取绝对路径
//public String getPath ():获取相对路径
//public String getParent () 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
//public File getParentFile () 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
//public long getTotalSpace () 返回此抽象路径名指定的分区大小。返回总容量单位字节
//public long getFreeSpace () 返回此抽象路径名指定的分区中未分配的字节数。返回剩余容量单位字节
//public String getName ():获取名称
//public long length ():获取长度。字节数
//public long lastModified ():获取最后一次的修改时间，毫秒值
//public String[] list ():获取指定目录下的所有文件或者文件夹的名称数组
//public File[] listFiles ():获取指定目录下的所有文件或者文件夹的File数组

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("F:\\ceshi");
        String[] list = file.list();
        for(String l:list){
        System.out.println(l);
        }
        File[] files = file.listFiles();
        for(File f:files) {
            System.out.println(f);
        }
    }
}
结果：
haha.txt
zqq
F:\ceshi\haha.txt
F:\ceshi\zqq
其实zqq目录里面还有文件，但是不能被遍历出来，只获得了本层的

16.IO流

基本字符流

public class CopyFileDemo2 {
    public static void main(String[] args) throws IOException {
        //字符流:只能读写文本文件
        InputStreamReader in = new InputStreamReader(new FileInputStream("MyDemo.java"，t
        ));
        //OutputStreamWriter将字节流转化为字符流
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("MyDemoCopy.java"));
       
        //读取一个字符数组
        int len = 0;
        char[] chars = new char[1000];
        while ((len = in.read(chars)) != -1) {
            out.write(chars, 0, len);
            out.flush(); //字符流记得刷新一些
        }
        //释放资源
        in.close();
        out.close();
    }
}

高效的字符流

public class IODemo2 {
    public static void main(String[] args) throws IOException {
        //高效的字符流里面有特的方法
        BufferedReader reader = new BufferedReader(new FileReader("MyDemo.java"));
        BufferedWriter writer = new BufferedWriter(new FileWriter("MyDemo4.java"));
        String line=null;
        //reader.readLine() 高效字符输入流特有的方法,一次读取一行
        //writer.newLine(); 高效字符输出流里面特有的方法
        while ((line=reader.readLine())!=null){
            writer.write(line);
           // writer.write("\r\n");
            writer.newLine();//写入一个换行符 具有平台兼容性
            writer.flush();//记得刷新

        }

        //释放资源
        reader.close();
        writer.close();
    }
}

```
    转换流              	便捷类
```
OutputStreamWriter ------- FileWriter
InputStreamReader ------- FileReader

17.

未解

1.为何反向遍历不出来？

public class MyDemo {
    public static void main(String[] args) {
        //集合:是一个容器,只能存储引用数据类型
        //集合体系:Collection--List--Set
        //List------ArrayList LinkedSet Vector
        //遍历 通过迭代器进行遍历
        //List集合特点:元素有序,每个元素都有索引,允许存储重复元素
        List arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(300);
        arrayList.add(400);
        arrayList.add(500);
        arrayList.add(600);
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()) {

            Object next = listIterator.next();
            System.out.println(next);
        }
        //boolean hasPrevious ()
        //如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
        //E previous ()
        //返回列表中的前一个元素。
        //反向遍历之前,先要正向遍历
        System.out.println("-------------------------------");
        ListIterator listIterator1 = arrayList.listIterator();
        while (listIterator1.hasPrevious()) {
            Object obj = listIterator1.previous();
            System.out.println(obj);
        }
    }
}
输出结果：
100
200
100
200
300
400
500
600

你的小天使

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
java基础部分典型代码

1.二分查找public class ArrayDemo2 { public static void main(String[] args) { //二分查找 int[] arr={10,20,30,50,60,70,80}; int index=findIndex(arr,50); System.out.println(i...
复制链接

扫一扫