java小编程练习笔记

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java小编程练习笔记，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12835字，纯文字阅读大概需要19分钟。

内容图文


import java.io.*;
import java.math.BigInteger;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Scanner;

/**
 * @author lw
 * @createTime 2018/11/14 20:42
 * @description 文件操作
 */
public class WrongFileTest {

    // 创建具有指定路径的文件对象
    @Test
    public void filedome() {
        File file = new File("ddd.txt");
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
        } catch (IOException e) {
            System.out.println("创建失败");
            e.printStackTrace();
        }

        // 创建具有指定路径的文件对象
        // 指定的盘符被占用，不是正常的存储盘符
        File file1 = new File(".\\sds\\jj");
        File txtfile = new File(file1, "atxt.txt");
        file1.mkdirs();
        try {
            txtfile.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    @Test
    public void filedome1() {

        File dirs = new File(".");
        String[] list = dirs.list();
        for (String string : list) {
            System.out.println(string);
        }

        System.out.println("------------------");
        File[] files = dirs.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
        File file1 = new File("a.txt");
        Date d = new Date(file1.lastModified());                //文件的最后修改时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        System.out.println(sdf.format(d));
    }

    @Test
    public void filedome2() throws Exception {

//        判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
        File dirs = new File("d:\\");
        //第一种
        File[] subfile = dirs.listFiles();
        for (File files : subfile) {
            if (files.isFile() && files.getName().endsWith(".jbj")) {
                System.out.println(files);
            }
        }
        //第二种
        String[] list = dirs.list();
        for (String string : list) {
            if (string.endsWith("*.jpg")) {
                System.out.println(string);
            }
        }

        //第三种
        String[] arr = dirs.list(new FilenameFilter() {   //内部类实现
            @Override
            public boolean accept(File dir, String name) {
                File file = new File(dir, name);
                return file.isFile() && file.getName().endsWith("*.jpg");
            }
        });
        for (String string : arr) {
            System.out.println(string);
        }

        //使用文件名称过滤器筛选将指定文件夹下的小于200K的小文件获取并打印
        File sudir = new File("c:\\");
        String[] filelength = sudir.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File fillen = new File(dir, name);
                return (fillen.length() / 1024 < 200) ? true : false;
            }
        });
        for (String name : filelength) {
            System.out.println(name);
        }

    }

    @Test
    public void filedome3() throws IOException {

        FileInputStream fis = new FileInputStream("a.txt");
        int a;
        byte[] arr = new byte[4];
        while ((a = fis.read(arr)) != -1) {
            System.out.print(new String(arr, 0, a));
        }
        fis.close();

        System.out.println("======================================");
        FileReader fr = new FileReader("a.txt");
        int c;
        while ((c = fr.read()) != -1) {
            System.out.print((char) c);
        }
        fr.close();

    }

    /**
     * @param :args
     * @throws :IOException close方法
     *                      具备刷新的功能,在关闭流之前,就会先刷新一次缓冲区,将缓冲区的字节全都刷新到文件上,再关闭,close方法刷完之后就能写了
     *                      flush方法?
     *                      具备刷新的功能,刷完之后还可以继续写
     */
    @Test
    public void filedome4() throws Exception {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("se.txt"));
        byte[] arr = new byte[1024];
        int len;
        while ((len = bis.read()) != -1) {
            bos.write(arr, 0, len);
        }
        bis.close();
        bos.close();
    }

    /**
     * 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出
     * <p>
     * 分析:
     * 1,创建键盘录入对象
     * 2,创建输出流对象,关联text.txt文件
     * 3,定义无限循环
     * 4,遇到quit退出循环
     * 5,如果不quit,就将内容写出
     * 6,关闭流
     *
     * @throws :IOException
     */
    @Test
    public void filedome5() throws Exception {

        Scanner scanner = new Scanner(System.in);
        FileOutputStream fos = new FileOutputStream("atx.txt");
        while (true) {
            String line = scanner.nextLine();
            if ("qute".equals(line)) {
                break;
            }
            fos.write(line.getBytes());
            fos.write("\t\n".getBytes());
        }
        fos.close();
    }

    @Test
    public void filedome6() {

    }

    @Test
    public void filedome7() throws Exception {
//        FileWriter ss = new FileWriter("ss");
//        ss.write("您好！！！");
//        ss.close();

        BufferedReader bufferedReader = new BufferedReader(new FileReader("a.txt"));
//        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("a.txt"));
        String lin;
        while ((lin = bufferedReader.readLine()) != null) {
            System.out.println(lin);
        }
        bufferedReader.close();

    }

    //将一个文本文档上的文本反转,第一行和倒数第一行交换,第二行和倒数第二行交换
    @Test
    public void filedome8() throws Exception {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("at.txt"));
        ArrayList<String> list = new ArrayList<>();
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            list.add(line);
        }
        bufferedReader.close();
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("cc.txt"));
        for (int i = list.size() - 1; i >= 1; i--) {
            bufferedWriter.write(list.get(i));
            bufferedWriter.newLine();
        }
        bufferedWriter.close();
    }

    //    获取一个文本上每个字符出现的次数,将结果写在times.txt上
    @Test
    public void filedome9() throws Exception {

        BufferedReader bufferedReader = new BufferedReader(new FileReader("a.txt"));
        HashMap<Character, Integer> mp = new HashMap<>();
        int c;
        while ((c = bufferedReader.read()) != -1) {
            char hc = (char) c;
            mp.put(hc, !mp.containsKey(hc) ? 1 : mp.get(hc) + 1);
        }
        bufferedReader.close();
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("cdsd"));
        for (Character key : mp.keySet()) {
            bufferedWriter.write(key + "==" + mp.get(key));
        }
        bufferedWriter.close();
    }

    public static int jceng(int num) {
        if (num == 1) {
            return 1;
        } else {
            return num * jceng(num - 1);
        }
    }

    //    获取一个文本上每个字符出现的次数,将结果写在times.txt上
    @Test
    public void filedome10() throws Exception {

        BufferedReader bf = new BufferedReader(new FileReader("ssss"));
        HashMap<Character, Integer> map = new HashMap<>();
        int c;
        while ((c = bf.read()) != -1) {
            char hc = (char) c;
            if (!map.containsKey(hc)) {
                map.put(hc, 1);
            } else {
                map.put(hc, map.get(hc) + 1);
            }
        }
        bf.close();
        BufferedWriter bw = new BufferedWriter(new FileWriter("sw"));
        for (Character key : map.keySet()) {
            bw.write(key + "===" + map.get(key));
        }

        bf.close();
    }

    //    从键盘接收一个文件夹路径,统计该文件夹大小/
    @Test
    public void filedome11() throws Exception {
//        Scanner scanner = new Scanner(System.in);
//        String arr = scanner.nextLine();
        File file = new File("D:\\TOOL\\IDEASpace\\mavedome\\src\\test\\java\\Fu");
        if (!file.exists()) {
            System.out.println("您输入的不是路径");
            System.exit(0);
        }
        int len = 1;
        File[] files = file.listFiles();
        for (File fils : files) {
            len += fils.length();
        }
        System.out.println(len);

    }

    @Test
    public void filedome12() throws Exception {

        BufferedReader br = new BufferedReader(new FileReader("ssd"));
        String line = br.readLine();
        int times = Integer.parseInt(line);
        if (times > 0) {
            //4,在if判断中要将--的结果打印,并将结果通过输出流写到文件上
            System.out.println("您还有" + times-- + "次机会");
            FileWriter fileWriter = new FileWriter("con,txt");
            fileWriter.write(times + " ");
            fileWriter.close();
        } else {
            System.out.println("您的试用次数已到,请购买正版");
        }
        br.close();

    }

    /**
     * 需求:1,从键盘接收一个文件夹路径,统计该文件夹大小
     * <p>
     * 从键盘接收一个文件夹路径
     * 1,创建键盘录入对象
     * 2,定义一个无限循环
     * 3,将键盘录入的结果存储并封装成File对象
     * 4,对File对象判断
     * 5,将文件夹路径对象返回
     * <p>
     * 统计该文件夹大小
     * 1,定义一个求和变量
     * 2,获取该文件夹下所有的文件和文件夹listFiles();
     * 3,遍历数组
     * 4,判断是文件就计算大小并累加
     * 5,判断是文件夹,递归调用
     */
    @Test
    public void filedome13() {

        File file = new File("D:\\TOOL\\IDEASpace\\mavedome\\src\\test");
        System.out.println(getDirlenth(file));
    }

    /**
     * 统计该文件夹大小
     * 1,返回值类型long
     * 2,参数列表File dir
     */
    public static Long getDirlenth(File dir) {

        long length = 0;
        File[] files = dir.listFiles();
        for (File subfiles : files) {
            if (subfiles.isFile()) {
                length += subfiles.length();
            } else {
                length += getDirlenth(subfiles);
            }
        }
        return length;
    }

    /**
     * 删除该文件夹
     * 1,返回值类型 void
     * 2,参数列表File dir
     */
    public static void deleteFile(File dir) {

        File[] subfil = dir.listFiles();
        for (File fils : subfil) {
            if (fils.isFile()) {
                fils.delete();
            } else {
                deleteFile(fils);
            }
        }
        dir.delete();
    }

    /**
     * 从键盘接收一个文件夹路径
     * 1,返回值类型File
     * 2,参数列表无
     */
    public static File getDir() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入文件路径");
        while (true) {
            String dir = scanner.nextLine();
            File file = new File(dir);
            if (!file.exists()) {
                System.out.println("您录入的文件夹路径不存在,请输入一个文件夹路径");
            } else if (file.isFile()) {
                System.out.println("您录入的是文件路径,请输入一个文件夹路径");
            } else {
                return file;
            }
        }
    }

    /**
     * 需求:3,从键盘接收两个文件夹路径,把其中一个文件夹中
     * (包含内容)拷贝到另一个文件夹中
     * <p>
     * 把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
     * 分析:
     * 1,在目标文件夹中创建原文件夹
     * 2,获取原文件夹中所有的文件和文件夹,存储在File数组中
     * 3,遍历数组
     * 4,如果是文件就用io流读写
     * 5,如果是文件夹就递归调用
     *
     * @throws: IOException
     */
    @Test
    public void filedome14() throws Exception {
        File str = getDir();
        File dest = getDir();
        if (str.equals(dest)) {
            System.out.println("路径一致");
        } else {
            copy(str, dest);
        }

    }

    /*
     * 把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
     * 1,返回值类型void
     * 2,参数列表File src,File dest
     */
    public static void copy(File src, File dest) throws Exception {
        File newdir = new File(dest, src.getName());
        File[] subfiles = newdir.listFiles();
        for (File subfil : subfiles) {
            if (subfil.isFile()) {
                BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(subfil));
                BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(new File(newdir, subfil.getName())));
                int len;
                while ((len = bufferedInputStream.read()) != -1) {
                    bufferedOutputStream.write(len);
                }
                bufferedInputStream.close();
                bufferedOutputStream.close();
            } else {
                copy(subfil, newdir);
            }
        }
    }

    @Test
    public void filedome15() {
//        File file = new File("C:\\Users\\lw\\Desktop\\课件\\day23_code\\讲师代码");
//        printLev(file,0);

        String rootFolderPath = "C:\\Users\\lw\\Desktop\\课件\\day23_code\\讲师代码";
        showTree(0, new File(rootFolderPath));

    }

    public static void printLev(File dir, int lev) {
        //1,把文件夹中的所有文件以及文件夹的名字按层级打印
        File[] files = dir.listFiles();
        for (File file : files) {
            for (int i = 0; i <= lev; i++) {
                System.out.print("\t");
            }
            //3,无论是文件还是文件夹,都需要直接打印
            System.out.println(file.getName());
            if (file.isDirectory()) {
                printLev(file, ++lev);
            }
        }

    }

    public static void showTree(int level, File parentFolderPath) {
        if (parentFolderPath.isDirectory()) {
            File[] childFiles = parentFolderPath.listFiles();
            for (File file : childFiles) {
                showNameByLevel(level);
                System.out.println(file.getName());
                if (file.isDirectory()) {
                    showTree(level + 1, file);
                }
            }
        }
    }

    public static void showNameByLevel(int level) {
        StringBuffer spaceStr = new StringBuffer();
        if (level > 0) {
            for (int i = 0; i < level; i++) {
                spaceStr.append(" ");
            }
        }
        if (spaceStr.length() > 0) System.out.print("|" + spaceStr);
        System.out.println("|");
        if (spaceStr.length() > 0) System.out.print("|" + spaceStr);
        System.out.print("----");
    }

    /**
     * * 不死神兔
     * 故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。
     * 在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡，
     * 问：一对刚出生的兔子，一年内繁殖成多少对兔子?
     * 1 1 2 3 5 8 13 21
     * 1 = fun(1)
     * 1 = fun(2)
     * 2 = fun(1) + fun(2)
     * 3 = fun(2) + fun(3)
     */
    @Test
    public void filedome16() {
        System.out.println(fun(8));
    }

    /*
     * 用递归求斐波那契数列
     */
    public static int fun(int num) {
        if (num == 1 || num == 2) {
            return 1;
        } else {
            return fun(num - 2) + fun(num - 1);
        }
    }

    /**
     * @Author:lw
     * @Description: 需求:求出1000的阶乘所有零和尾部零的个数,不用递归做
     * @Date:12:18 2018/11/15
     */
    @Test
    public void filedome17() {
        //求1000的阶乘中所有的零
        BigInteger bi1 = new BigInteger("1");
        for (int i = 1; i <= 1000; i++) {
            BigInteger bi2 = new BigInteger(i + "");
            bi1 = bi1.multiply(bi2); //将bi1与bi2相乘的结果赋值给bi1
        }
        String str = bi1.toString();//获取字符串表现形式
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if (‘0‘ == str.charAt(i)) {  //如果字符串中出现了0字符
                count++;
            }
        }
        System.out.println(count);
    }

    @Test
    public void filedome18() {
        //获取1000的阶乘尾部有多少个零
        BigInteger bi1 = new BigInteger("1");
        for (int i = 1; i <= 1000; i++) {
            BigInteger bi2 = new BigInteger(i + "");
            bi1 = bi1.multiply(bi2);
        }
        String str = bi1.toString();
        StringBuffer stringBuffer = new StringBuffer(str);
        str = stringBuffer.reverse().toString(); //链式编程
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if (‘0‘ != str.charAt(i)) {
                break;
            } else {
                count++;
            }
        }
        System.out.println(count);
    }

    /**
     * @param :args 需求:求出1000的阶乘尾部零的个数,用递归做
     *              5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100...1000  1000 / 5 = 200
     *              5 * 5   5 * 5 * 2   5 * 5 * 3   5 * 5 * 4   5 * 5 * 5   5 * 5 * 6   200 / 5 = 40
     *              5 * 5 * 5 * 1   5 * 5 * 5 * 2   5 * 5 * 5 * 3   5 * 5 *  5 * 4  5 * 5 *  5 * 5  5 * 5 *  5 * 6  5 * 5 *  5 * 7  5 * 5 *  5 * 8
     *              40 / 5 = 8
     *              5 * 5 * 5 * 5                                                       8 / 5 = 1
     */
    @Test
    public void filedome19() {
        System.out.println(fun1(1000));
    }
    //    需求:求出1000的阶乘尾部零的个数,用递归做
    public static int fun1(int num) {
        if (num > 0 && num < 5) {
            return 0;
        } else {
            return num / 5 + fun1(num / 5);
        }
    }

    /**
     * 获取幸运数字
     * 1,返回值类型int
     * 2,参数列表int num
     */
    @Test
    public void filedome20() {
        System.out.println(getLucklyNum(384));
    }

    /**
     * 获取幸运数字
     * 1,返回值类型int
     * 2,参数列表int num
     */
    public static int getLucklyNum(int num) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= num; i++) {
            list.add(i);
        }
        int ncout = 1;                            //用来数数的,只要是3的倍数
        for (int i = 0; list.size() != 1; i++) {   //只要集合中人数超过1
            if (i == list.size()) {           //如果i增长到集合最大的索引+1时
                i = 0;                       //重新归零
            }
            if (ncout % 3 == 0) {
                list.remove(i--);
            }
            ncout++;
        }
        return list.get(0);
    }

原文：http://blog.51cto.com/357712148/2317267

内容总结

以上是互联网集市为您收集整理的java小编程练习笔记全部内容，希望文章能够帮你解决java小编程练习笔记所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1282547.html

来源：【匿名】

【上一篇】java逻辑运算【下一篇】JAVA/JSP学习系列之五

更多 ►

【java小编程练习笔记】教程文章相关的互联网学习教程文章

import java.io.*; import java.math.BigInteger; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.Scanner;/*** @author lw* @createTime 2018/11/14 20:42* @description 文件操作*/ public class WrongFileTest {// 创建具有指定路径的文件对象@Testpublic void filedome() {File file = new File("ddd.txt");try {if (!file.exists()) {f...

java中的编程规范

本规范中标红的内容为强制性遵循内容,开发人员必须遵守;蓝色为强烈建议性内容,最好遵守;其他内容为一般性建议.不足之处欢迎大家指点补充.1.命名规则1.1基本的规则1,字符集在26个英文字母、0到9的阿拉伯数字和下划线之中.java中类、字段、方法、变量、常量尽量用字母表达,没有特别的理由不能用其他任何的字符.2,命名需要有一定的意义,推荐采用问题域中的术语命名,使命名在一定程度上是自描述的.3,命名尽量的短,如果命名太长,可以采用...

JavaScript基础- 编程语言【代码】【图】

1 - 编程语言1.1 编程编程：就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程。计算机程序：就是计算机所执行的一系列的指令集合，而程序全部都是用我们所掌握的语言来编写的，所以人们要控制计算机一定要通过计算机语言向计算机发出命令。1.2 计算机语言计算机语言指用于人与计算机之间通讯的语言，它是人与计算机之间传递信息的媒介。计算机语言的种类非常的多，总的来说可以分成机器语言，...

Java——网络编程

??// TODO Auto-generated method stub//获取本地主机IP对象InetAddress ip = InetAddress.getLocalHost();System.out.println(ip.getHostAddress());System.out.println(ip.getHostName());//获取其他主机ip地址对象ip = InetAddress.getByName("www.sina.com");System.out.println(ip.getHostAddress());System.out.println(ip.getHostName());通讯的两端UDP建立System.out.println("发送端启动--------------------------------...

Java 多线程编程教程线程的运行与控制【代码】

在多个线程同时运行时，就存在多个线程之间的调度控制、资源分配等。本节就来讲解线程使用中的一系列控制命令和使用方法线程的启动start()、join()与停止stop()线程的休眠sleep()、挂起yield线程的同步synchronized线程的同步锁机制：wait()、notify()和notifyAll() start()启动线程，当线程创建之后，利用start方法启动线程。此外还可以利用join方法让线程立即执行 sleep()让当前线程暂停一段时间之后继续执行。sleep(）方法...

Java并发编程：volatile关键字解析【代码】【图】

volatile这个关键字可能很多朋友都听说过，或许也都用过。在Java 5之前，它是一个备受争议的关键字，因为在程序中使用它往往会导致出人意料的结果。在Java 5之后，volatile关键字才得以重获生机。　　volatile关键字虽然从字面上理解起来比较简单，但是要用好不是一件容易的事情。由于volatile关键字是与Java的内存模型有关的，因此在讲述volatile关键之前，我们先来了解一下与内存模型相关的概念和知识，然后分析了volatile关键字...

Java并发编程与技术内幕:ThreadGroup线程组应用【代码】

package com.xinboedu.www.test;/*** 功能概要：* * @author linbingwen* @since 2016年6月11日*/publicclass ThreadGroupDemo {publicstaticvoid main(String[] args) {ThreadGroup threadGroup1 =// 这是匿名类写法new ThreadGroup("group1") {// 继承ThreadGroup并重新定义以下方法// 在线程成员抛出unchecked exception// 会执行此方法publicvoid uncaughtException(Thread t, Throwable e) {System.out.println(t.getName() +...

Java 网络编程【代码】【图】

1. Socket 编程原理网络上的实体通过端到端的连接进行数据的发送与接收，即进行通信。通信的一端就叫做一个socket。要通过socket进行通信，服务端和客户端都需要为通信做一些准备。首先，服务端需要初始化socket，然后为socket绑定端口和IP，客户端使用这个IP和端口表名要与哪个服务端进行通信。然后，服务端对socket进行监听客户端需要初始化socket，绑定要连接的服务端的IP和端口，系统也会为客户端分配默认的IP和端口　　这时如...

JavaSE高级之GUI编程【代码】

下面主要用到了java中的swing进行界面设计，当然java的GUI不如C#的设计的好看，不过原理还是要会的。1． GUI Graphical User Interface 用户图形界面 a) 主要包括菜单栏，窗口，工具条，按钮等； b) Java提供了两个GUI开发的包 java.awt 和 java.swing, java.awt中的Component抽象类是javaGUI中所有类的父类。它规定了所有GUI组件的的的基本特性 j ava.swing 是在java.awt 的基础上构建起来的，引入了许多新的功能和新...

Java Swing界面编程(9)---BorderLayout布局管理器【图】

package com.beyole.util;import java.awt.BorderLayout; import java.awt.Button;import javax.swing.JFrame;public class test7 {public static void main(String[] args) {JFrame frame=new JFrame("Crystal");frame.setLayout(new BorderLayout(3,3));//设置为BorderLayout布局管理器frame.add(new Button("东-East"),BorderLayout.EAST);frame.add(new Button("西-West"),BorderLayout.WEST);frame.add(new Button("南-South"...

java基础学习总结——GUI编程(一) 还未仔细阅读【代码】【图】

一、AWT介绍　　所有的可以显示出来的图形元素都称为Component，Component代表了所有的可见的图形元素，Component里面有一种比较特殊的图形元素叫Container，Container(容器)在图形界面里面是一种可以容纳其它Component元素的一种容器，Container本身也是一种Component的，Container里面也可以容纳别的Container。　　Container里面又分为Window和Pannel，Window是可以独立显示出来的，平时我们看到的各种各样的应用程序的窗口都可...

Java并发编程-volatile可见性的介绍【代码】

前言要学习好Java的多线程,就一定得对volatile关键字的作用机制了熟于胸。最近博主看了大量关于volatile的相关博客,对其有了一点初步的理解和认识，下面通过自己的话叙述整理一遍。有什么用？volatile主要对所修饰的变量提供两个功能可见性防止指令重排序<br>本篇博客主要对volatile可见性进行探讨，以后发表关于指令重排序的博文。什么是可见性？一图胜千言上图已经把JAVA内存模型（JMM）展示得很详细了,简单概括一下每个Thread有...

Java面试编程题练手

面试编程写一个程序，去除有序数组中的重复数字编写一个程序使得两个线程陷入死锁使用递归算法反转字符串合并两个有序数组找出三个有序数组共有的元素字符(字母、数字、中文字符)统计示例最短时间过桥从一个整数数组中找出总和为S的所有子集5个钢珠离开凹轨的最短时间和最长时间1到50个数，每次去掉两个数，增加两个数差的绝对值，最后剩什么数？为什么？输出全排列随机产生和为S的N个正整数Java洗牌判断一个集合能否分成和一致的两...

Java_基础语法编程练习【代码】

一:让计算机随机产生100个0到100之间的整数，每个整数代表某个学生的成绩，计算这些成绩的平均值 publicstaticvoid main(String[] args) {int sum = 0;for(int i = 0 ;i < 100 ;i++) {int n = (int) (Math.random()*101);sum += n;}System.out.println("平均值为:" + (sum/100.0));}二: 输入一个100-999的数,判断它是不是水仙花数publicstaticvoid main(String[] args) throws MyException {System.out.println("请输入一个大于100...

【51CTO学院三周年】编程成长感悟，基于R，Python和JAVA

这是我自己编程技能提升途径的总结，主要有以下三点：业务驱动，修炼技能合作需求，扩展技能个人兴趣，不为金钱，只为快乐和创造最近刚入职两个月，同样从事的是生物信息分析，之所以从事当前这个行业，原因在于读大学时几乎大多数的专家，高级知识分子都提出“21世纪是生命科学的世纪”，于是当时读的是生物科学专业。可是编程技能，在大学我掌握的只有C语言，而且对于C语言的指针感到一片茫然，当然这跟我当时读的专业几乎...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...