java入坑之国际化编程

最新推荐文章于 2024-06-14 14:08:37 发布
最新推荐文章于 2024-06-14 14:08:37 发布
阅读量309 收藏
点赞数
分类专栏： JAVA入坑 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62377885/article/details/133614180
版权

一、字符编码

1.1概述

字符编码
--字符：0，a,我，①，,…
--计算机只用0和1,1bit(0或者1)
--ASCIL码(American Standard Code for Information Interchange)

  • ·美国信息交换标准代码，奠定计算机编码基础
  • ·用一个字节(1Byte=8bits)来存储a-z,A-Z,0-9和一些常用符号
  • ·用于显示英语及西欧语言
  • ·回车键(13,00001101)，0(48,00110000)，A(65,01000001),a(97,01100001)

package org.example;

import java.io.UnsupportedEncodingException;

public class StringTest {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String a = "我是中国人";
        String b = new String(a.getBytes("UTF-8"), "GBK");
        System.out.println(b);
        String c = new String(b.getBytes("GBK"), "UTF-8");
        System.out.println(c);
    }
}

 1.2中文编码

字符集        包括哪些字符元素；
编码        每个字符元素用多少号码        (0和1的组合)来表示

1.3Unicode(字符集)

Unicode(字符集)
一目标：不断扩充，存储全世界所有的字符
·编码方案

  • UTF-8，兼容ASCⅡ，变长(1-4个字节存储字符)，经济，方便传输
  • UTF-16，用变长(2-4个字节)来存储所有字符
  • UTF-32，用32bits(4个字节)存储所有字符

写文件

package org.example;

import java.io.*;

public class Main {
    public static void main(String[] args) {
        writeFile1();
    }

    public static void writeFile1() {
        FileOutputStream fos = null;
        OutputStreamWriter osw = null;
        BufferedWriter bw = null;
        String charset = "UTF-8";
        try {
            fos = new FileOutputStream("c:/temp/abc.txt"); // 节点类
            osw = new OutputStreamWriter(fos, charset); // 转化类
//osw  =  new  OutputStreamWriter(fos)； //  转化类 采用操作系统默认编码
            bw = new BufferedWriter(osw); // 装饰类
// br = new BufferedWriter(new OutputStreamWriter(newFileOutputStream("c:/temp/abc.txt")))
            bw.write("我们是");
            bw.newLine();
            bw.write("Ecnuers.^^");
            bw.newLine();
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                bw.close();// 关闭最后一个类，会将所有的底层流都关闭
            } catch (Exception ex) {
                ex.printStackTrace();
            }

        }
    }
}

读文件

package org.example;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {
        readFile1();
    }
    public static void readFile1(){
        FileInputStream fis=null;
        InputStreamReader isr=null;
        BufferedReader br=null;
        String charset="UTF-8";
        try{
            fis=new FileInputStream("c:/temp/abc.txt"); // 节点类
            isr=new InputStreamReader(fis,charset); // 转化类
//isr = new InputStreamReader(fis); //采用操作系统默认编码
            br=new BufferedReader(isr); // 装饰类
// br = new BufferedReader(new InputStreamReader(newFileInputStream("c:/temp/abc.txt")))
            String line;
            while((line=br.readLine())!=null) // 每次读取一行
            {
                System.out.println(line);
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }finally{
            try{
                br.close();// 关闭最后一个类，会将所有的底层流都关闭
            }catch(Exception ex){
                ex.printStackTrace();
            }
        }
    }
}

1.4ANSI编码

1.5Java的字符编码

package org.example;

import java.nio.charset.Charset;
import java.util.Set;
import java.util.SortedMap;
public class Main {
    public static void main(String[] args) {
//默认字符集 GBK
        Charset c = Charset.defaultCharset();
        System.out.println(c.name());
//输出所有的支持字符集
        SortedMap<String, Charset> sm = Charset.availableCharsets();
        Set<String> keyset = sm.keySet();
        System.out.println("Java 支持的所有字符集");
        for (String s : keyset) {
            System.out.println(s);

        }
    }
}

java charset类是一个用于表示字符编码集的类，它可以用于将字符序列和字节序列之间进行转换和处理。字符编码集是一种将字符和数字之间进行映射的规则，例如ASCII、UTF-8、GBK等。不同的字符编码集可能支持不同的字符集合，因此在不同的编码之间转换时可能会出现乱码或丢失信息的情况。java charset类提供了一些方法和工具，用于检测、创建和管理不同的字符编码集

java charset类的主要方法有：

  1. static Charset forName(String charsetName)：根据给定的字符编码集名称，返回一个Charset对象，如果不存在或不支持该名称，则抛出异常。
  2. static Charset defaultCharset()：返回当前Java虚拟机的默认字符编码集，它通常取决于底层操作系统的语言环境和字符编码。
  3. static SortedMap<String,Charset> availableCharsets()：返回一个包含当前Java虚拟机支持的所有字符编码集的映射，其中键是规范名称，值是Charset对象。
  4. String name()：返回该字符编码集的规范名称。
  5. Set<String> aliases()：返回该字符编码集的别名集合，别名是除了规范名称之外的其他有效名称。
  6. boolean isRegistered()：返回该字符编码集是否在IANA Charset Registry中注册，如果没有注册，则其规范名称必须以"X-"或"x-"开头。
  7. boolean canEncode()：返回该字符编码集是否可以对任意Unicode字符进行编码12。
  8. boolean contains(Charset cs)：返回该字符编码集是否包含给定的字符编码集，即该字符编码集可以表示给定字符编码集中的所有字符。
  9. CharsetEncoder newEncoder()：返回一个新的CharsetEncoder对象，用于将字符序列转换为字节序列。
  10. CharsetDecoder newDecoder()：返回一个新的CharsetDecoder对象，用于将字节序列转换为字符序列
package org.example;

import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CharsetDecoder;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;

public class CharsetDemo {
    public static void main(String[] args) throws Exception {
        // 获取默认字符编码集
        Charset cs = Charset.defaultCharset();
        System.out.println("默认字符编码集：" + cs.name());

        // 获取UTF-8字符编码集
        cs = Charset.forName("UTF-8");
        System.out.println("UTF-8字符编码集：" + cs.name());

        // 创建一个UTF-8编码器
        CharsetEncoder encoder = cs.newEncoder();

        // 创建一个UTF-8解码器
        CharsetDecoder decoder = cs.newDecoder();

        // 定义一个要转换的字符串
        String str = "你好，世界！";

        // 将字符串转换为字节缓冲区
        ByteBuffer bb = encoder.encode(CharBuffer.wrap(str));
        System.out.println("转换后的字节缓冲区：" + bb);

        // 将字节缓冲区转换为字符串
        CharBuffer cb = decoder.decode(bb);
        System.out.println("转换后的字符串：" + cb);
    }
}

二、国际化编程

2.1格式化相关类

数字格式化

import java.text.DecimalFormat;

public class DecimalFormaterRuleTest {
    public static void main(String[] args) {
        DecimalFormat df1, df2;
        System.out.println("整数部分为0的情况，0/#的区别");
        // 整数部分为0 ，#认为整数不存在，可不写； 0认为没有，但至少写一位，写0
        df1 = new DecimalFormat("#.00");
        df2 = new DecimalFormat("0.00");
        System.out.println(df1.format(0.1)); // 0.10
        System.out.println(df2.format(0.1)); // 0.10

        System.out.println("小数部分0/#的区别");
        // # 代表最多有几位，0代表必须有且只能有几位
        df1 = new DecimalFormat("0.00");
        df2 = new DecimalFormat("0.##");
        System.out.println(df1.format(0.1)); // 0.10
        System.out.println(df2.format(0.1)); // 0.1
        System.out.println(df1.format(0.006)); // 0.01
        System.out.println(df2.format(0.006)); // 0.01

        System.out.println("整数部分有多位");
        // 0和#对整数部分多位时的处理是一致的 就是有几位写多少位
        df1 = new DecimalFormat("0.00");
        df2 = new DecimalFormat("#.00");
        System.out.println(df1.format(2)); // 2.00
        System.out.println(df2.format(2)); // 2.00
        System.out.println(df1.format(20)); // 20.00
        System.out.println(df2.format(20)); // 20.00
        System.out.println(df1.format(200)); // 200.00
        System.out.println(df2.format(200)); // 200.00
    }
}

package org.example;

import java.text.DecimalFormat;

public class DecimalFormatTest {
    public static void main(String[] args) {
        DecimalFormat df1 = new DecimalFormat("0.0");
        DecimalFormat df2 = new DecimalFormat("#.#");
        DecimalFormat df3 = new DecimalFormat("000.000");
        DecimalFormat df4 = new DecimalFormat("###.###");
        System.out.println(df1.format(12.34)); // 12.3
        System.out.println(df2.format(12.34)); // 12.3
        System.out.println(df3.format(12.34)); // 012.340
        System.out.println(df4.format(12.34)); // 12.34

        DecimalFormat df5 = new DecimalFormat("0.00");// 保留2位小数
        double d1 = 123456789.123456789;
        double d2 = 987654321.987654321;
        System.out.println("format1 d1=" + df5.format(d1));// 输出: format1 d1=123456789.12
        System.out.println("format1 d2=" + df5.format(d2));// 输出: format1 d2=987654321.99

        DecimalFormat df6 = new DecimalFormat("#,##0.00");
        System.out.println("format2 d1=" + df6.format(d1));// 输出: format2 d1=123,456,789.12
        System.out.println("format2 d2=" + df6.format(d2));// 输出: format2 d2=987,654,321.99
    }
}

字符串格式化

package org.example;

import java.text.MessageFormat;

public class MessageFormatTest {
    public static void main(String[] args) {
        String message = "{0}{1}{2}{3}{4}";
        Object[] array = new Object[]{"A","B","C","D","E"};
        String value = MessageFormat.format(message, array);
        System.out.println(value);

        message = "oh, {0,number,#.##} is a good number";
        array = new Object[]{new Double(3.1415)};
        value = MessageFormat.format(message, array);
        System.out.println(value);
    }
}

时间格式化

package org.example;

import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateTest {
    public static void main(String[] args) {
        String strDate = "2008-10-19 10:11:30.345";
        // 准备第一个模板，从字符串中提取出日期数字
        // 将毫秒部分改为大写的S
        String pat1 = "yyyy-MM-dd HH:mm:ss.SSS"; //修正了大小写
        // 准备第二个模板，将提取后的日期数字变为指定的格式
        String pat2 = "yyyy年MM月dd日HH时mm分ss秒SSS毫秒";
        SimpleDateFormat sdf1 = new SimpleDateFormat(pat1); // 实例化模板对象
        SimpleDateFormat sdf2 = new SimpleDateFormat(pat2); // 实例化模板对象
        Date d = null;
        try {
            d = sdf1.parse(strDate); // 将给定的字符串中的日期提取出来
        } catch (Exception e) { // 如果提供的字符串格式有错误，则进行异常处理
            e.printStackTrace(); // 打印异常信息
        }
        System.out.println(sdf2.format(d)); // 将日期变为新的格式
    }
}

package org.example;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class DateFormatterTest {
    public static void main(String[] args) {
        //将字符串转化为时间
        String dateStr= "2016年10月25日";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        LocalDate date= LocalDate.parse(dateStr, formatter);
        System.out.println(date.getYear() + "-" + date.getMonthValue() + "-" + date.getDayOfMonth());
        System.out.println("==========================");
        //将日期转换为字符串输出
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss");
        String nowStr = now.format(format);
        System.out.println(nowStr);
    }
}

 2.2Locale类

package org.example;

import java.util.Locale;
import java.text.DateFormat;
import java.util.Date;

public class LocaleDemo {
    public static void main(String[] args) {
        // 创建一个中文简体的语言环境
        Locale cn = Locale.SIMPLIFIED_CHINESE;
        // 创建一个英文美国的语言环境
        Locale us = Locale.GERMAN;
        // 获取当前日期
        Date date = new Date();
        // 创建一个日期格式化器
        DateFormat df = DateFormat.getDateInstance(DateFormat.FULL, cn);
        // 使用不同的语言环境格式化日期
        System.out.println("中文简体：" + df.format(date));
        df = DateFormat.getDateInstance(DateFormat.FULL, us);
        System.out.println("英文美国：" + df.format(date));
    }
}

 java Locale类的主要方法有：

  1. static Locale getDefault()：返回当前Java虚拟机的默认语言环境，它通常取决于底层操作系统的设置。
  2. static Locale forLanguageTag(String languageTag)：根据给定的语言标签，返回一个Locale对象，如果语言标签无效或不支持，则返回一个空的Locale对象。
  3. static String toLanguageTag()：返回该Locale对象对应的语言标签，如果该Locale对象为空，则返回空字符串。
  4. String getLanguage()：返回该Locale对象的语言代码，如果该Locale对象为空，则返回空字符串。
  5. String getCountry()：返回该Locale对象的国家或地区代码，如果该Locale对象为空，则返回空字符串。
  6. String getScript()：返回该Locale对象的脚本代码，如果该Locale对象为空或没有指定脚本，则返回空字符串。
  7. String getVariant()：返回该Locale对象的变体代码，如果该Locale对象为空或没有指定变体，则返回空字符串。
  8. String getDisplayName()：返回该Locale对象的显示名称，根据默认语言环境进行本地化，如果该Locale对象为空，则返回空字符串

2.3 ResourceBundle类

java ResourceBundle类是一个用于表示特定的地理、政治和文化地区的类。每一个ResourceBundle对象都代表了一个语言环境，可以用于执行一些与区域相关的操作，例如格式化日期、时间、数字、货币等。java ResourceBundle类还支持IETF BCP 47标准，可以使用语言标签来表示不同的语言和地区

package org.example;

import java.util.Locale;
import java.util.ResourceBundle;

public class ResourceBundleDemo {
    public static void main(String[] args) {
        // 创建一个英文美国的语言环境
        Locale us = new Locale("en", "US");
        // 创建一个中文简体的语言环境
        Locale jp = new Locale("ja", "JP");

        // 根据基本名称和语言环境获取ResourceBundle对象
        ResourceBundle bundleUS = ResourceBundle.getBundle("Message", us);
        ResourceBundle bundleCN = ResourceBundle.getBundle("Message", jp);
        // 获取不同语言环境下的消息
        System.out.println("message from Message_en_US.properties: " + bundleUS.getString("message"));
        System.out.println("message from Message_ja_JP.properties: " + bundleCN.getString("message"));
    }
}

语言文件

Message_en_US.properties

message=Hello!

 Message_ja_JP.properties

message=こんにちは！

三、正则表达式

 3.1Pattern类

java Pattern类是一个用于表示正则表达式的编译表示形式的类，它可以用于对字符串进行匹配和处理。正则表达式是一种定义字符串模式的规则，可以用于搜索、编辑或验证文本。java Pattern类支持Perl风格的正则表达式语法，也支持Unicode字符集

package org.example;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MatcherDemo {
    public static void main(String[] args) {
        // 检查字符串里面有多少个dog
        String REGEX = "dog";
        String INPUT = "I have a dog, and my friend has a dog too.";

        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(INPUT);
        int count = 0;
        while (m.find()) {
            count++;
            System.out.println("Match number: " + count);
            System.out.println("start(): " + m.start());
            System.out.println("end(): " + m.end());
        }
        System.out.println(count);
    }
}

3.2 Matcher类

java Matcher类是一个用于执行正则表达式匹配操作的类，它实现了MatchResult接口，可以对一个字符序列按照一个Pattern对象进行解释和处理。要使用java Matcher类，需要先调用Pattern类的静态方法compile，将一个正则表达式字符串编译为一个Pattern对象，然后调用Pattern对象的matcher方法，创建一个Matcher对象，用于对输入字符串进行匹配操作

Matcher对象提供了一些方法，用于检查匹配结果和获取匹配信息，例如：

  1. boolean matches()：判断整个输入字符串是否与正则表达式完全匹配。
  2. boolean find()：判断输入字符串中是否存在与正则表达式匹配的子序列。
  3. boolean find(int start)：从指定位置开始，判断输入字符串中是否存在与正则表达式匹配的子序列。
  4. String group()：返回与正则表达式匹配的子序列。
  5. String group(int group)：返回与正则表达式中指定分组匹配的子序列。
  6. int groupCount()：返回正则表达式中分组的数量。
  7. int start()：返回与正则表达式匹配的子序列在输入字符串中的起始位置。
  8. int start(int group)：返回与正则表达式中指定分组匹配的子序列在输入字符串中的起始位置。
  9. int end()：返回与正则表达式匹配的子序列在输入字符串中的结束位置（不包含）。
  10. int end(int group)：返回与正则表达式中指定分组匹配的子序列在输入字符串中的结束位置（不包含）
package org.example;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MatchesLooking {
    private static final String REGEX = "foo";
    private static final String INPUT = "foooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main(String[] args) {
        // Initialize
        pattern = Pattern.compile(REGEX);
        matcher = pattern.matcher(INPUT);
        System.out.println("Current REGEX is: " + REGEX);
        System.out.println("Current INPUT is: " + INPUT);
        System.out.println("lookingAt(): " + matcher.lookingAt());  //部分匹配
        System.out.println("matches(): " + matcher.matches()); //完全匹配
    }
}

 3.3综合

Matcher对象还提供了一些方法，用于对输入字符串进行替换和追加操作，例如：

  1. Matcher appendReplacement(StringBuffer sb, String replacement)：将与正则表达式匹配的子序列替换为给定的字符串，并将结果追加到一个StringBuffer对象中。
  2. StringBuffer appendTail(StringBuffer sb)：将最后一次匹配操作后剩余的输入字符串追加到一个StringBuffer对象中。
  3. String replaceAll(String replacement)：将所有与正则表达式匹配的子序列替换为给定的字符串，并返回替换后的新字符串。
  4. String replaceFirst(String replacement)：将第一个与正则表达式匹配的子序列替换为给定的字符串，并返回替换后的新字符串

替换 

package org.example; //声明包名

import java.util.regex.Matcher; //导入Matcher类
import java.util.regex.Pattern; //导入Pattern类

public class RegexDemo { //定义公共类
    private static String REGEX = "a*b"; //*表示限定前面的a可以有0或者多个。
    private static String INPUT = "aabfooaabfooabfoobcdd";
    private static String REPLACE = "-";
    public static void main(String[] args) { 
        Pattern p = Pattern.compile(REGEX); //将正则表达式字符串编译为Pattern对象
        Matcher m = p.matcher(INPUT); //创建Matcher对象，用于对输入字符串进行匹配操作
        StringBuffer sb = new StringBuffer(); //创建StringBuffer对象，用于存储替换后的字符串
        //全部替换
        while(m.find()){ //循环查找与正则表达式匹配的子序列
            m.appendReplacement(sb,REPLACE); //将匹配的子序列替换为指定的字符串，并追加到StringBuffer对象中
        }
        //将最后的尾巴字符串附加上
        m.appendTail(sb); //将最后一次匹配操作后剩余的输入字符串追加到StringBuffer对象中
        System.out.println(sb.toString()); //输出替换后的字符串
    }
}

package org.example; //声明包名

import java.util.regex.Matcher; //导入Matcher类
import java.util.regex.Pattern; //导入Pattern类

public class ReplaceDemo2 {
    private static String REGEX = "a*b"; //*表示限定前面的a可以有0或者多个。
    private static String INPUT =
            "aabfooaabfooabfoob";
    private static String REPLACE = "-";
    public static void main(String[] args) {
        Pattern p = Pattern.compile(REGEX);
        // get a matcher object
        Matcher m = p.matcher(INPUT);
        // 使用replaceAll方法替换所有匹配的子序列，并赋值给一个新的字符串变量
        String output = m.replaceAll(REPLACE); //修正了赋值
        // 输出新的字符串变量
        System.out.println(output); //修正了输出
    }
}

邮箱的判定

package org.example;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexTest {
    public static void main(String[] args) {
        regularExpression();
    }

    public static void regularExpression() {
        String REGEX_EMAIL = "^\\w+([-+.']\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
        String[] emails = new String[]{"123^@qq.com", "name_321@163.com", "+whatever*72@gmail.com"};

        Pattern pattern = Pattern.compile(REGEX_EMAIL);

        for (String email : emails) {
            Matcher matcher = pattern.matcher(email);
            if (matcher.matches()) {
                System.out.println(email + " is a valid email.");
            } else {
                System.out.println(email + " is not a valid email.");
            }
        }
    }
}

烟雨平生9527
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java中的国际化
qfchenjunbo的博客
08-14 120
国际化，就是项目能够让所有的国家的语言都能够支持。Java既然作为一个跨平台的语言就必然要在各种不同的语言环境中使用。而为了解决这个问题Java给我们提供了一个工具类ResourceBundle，帮助我们实现Java的国际化， 核心的思想就是， 对不同的语言提供一个不同的资源文件。 Java实现国际化的步骤： 1. 编写要实现国际化的主程序。 2. 定义资源文件， 注意资源文件的定义要符合一...
JAVA基础编程——国际化
止步听风的博客
06-04 1481
在JAVA开发或是Android开发中，项目代码可能会应用到不同的国家或地区。此时就需要根据不同国家设置不同的语言文字，这里会存在两个问题：这里看一下具体是怎么实现的。Locale类为java.util.Locale，使用此类可以定义用户使用的语言环境： 这里看一下上面代码的结果： 执行结果为： 使用getDault可以获得当前语言环境中默认的Locale对象，同时也就获得了默认的语言环境，如zh_CN(语言标记_国家标记)，其中zh表示语言为中文，CN表示国家为中国。而使用构造或者使用类中的属
springmvc国际化demo
04-09
用springmvc做的一个国际化小例子，包含如何在页面和java代码中获取国际化资源
JAVA做语言国际化
pichcar1982的博客
04-04 1054
这里有个坑，就是如果不指定-encoding UTF-8，则这个命令会自动调用操作系统默认的中文编码即GB2312编码对属性文件转换成Unicode编码，这样转换后，因为属性文件使用的是UTF-8编码，这样到时候用java国际化翻译读出来的文字就是乱码，这点一定要注意！公司做SaaS系统，需要做成国际通用版本，至少支持简体中文，繁体中文和英文版本，然后我使用的是java的国际化方案，通过查资料和动手实践，踩过了几个坑。例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据。
Java 国际化
知乐的博客
03-06 768
表示特定的地理、政治和文化区域，需要 Locale 来执行任务的操作称为语言环境的敏感操作。属性文件（文件内容格式为 “key=value”），然后根据 Locale 环境进行解析。同一套程序代码可以在不同的语言环境下使用，比如中文、日文、英文环境。国际化的核心问题在于显示的语言，通常的做法是定义若干个。用于读取资源文件，读取时不需要加上文件类型后缀。动态的文本处理需要使用。
java程序国际化[38]
weixin_45539338的博客
09-17 323
java程序国际化[38]
代码国际化方式
qq_41303761的博客
01-05 229
代码国际化方式
深入了解Java 脚本化api编程
08-25
Java 脚本 API 是一种独立于框架的脚本语言，使用来自于Java代码的脚本引擎 。可以使用Java语言编写定制/可扩展的应用程序并将自定义脚本语言选择留给最终用户 。下面我们来详细了解一下吧
java图形化界面编程资料.zip
06-19
Java的图形化界面编程，从基础的AWT组件到高级的Swing组件，从单一的组件应用到丰富的图形效果，从简单的使用组件到复杂的图形绘制。
java图形化界面编程.md
04-19
java Swing 完整详细，可以说是一本书了，里面有讲课详述和代码实现
java编程实现国际象棋棋盘
08-26
主要为大家详细介绍了java编程实现国际象棋棋盘，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
围棋设计资料-讲解java的图形化界面编程
04-30
围棋设计资料-讲解java的图形化界面编程
java国际化实现代码_java基础---->java中国际化的实现
weixin_39712969的博客
02-16 327
应用程序的功能和代码设计考虑在不同地区运行的需要，其代码简化了不同本地版本的生产。开发这样的程序的过程，就称为国际化。今天，我们就开始学习java中国际化的代码实现。Java国际化主要通过如下3个类完成java.util.ResourceBundle:用于加载一个资源包java.util.Locale：对应一个特定的国家/区域、语言环境。java.text.MessageFormat：用于将消息格...
Java国际化ResourceBundle详解
IT可乐
02-22 1638
如果默认的资源加载机制无法满足需求，我们还可以自定义资源加载器来实现更高级的功能。自定义资源加载器需要继承java.util.ResourceBundle.Control类，并重写其中的方法来实现自定义逻辑。if(stream!= null) {try {} } else {// Bonjour在这个示例中，我们定义了一个名为MyResourceLoader的自定义资源加载器，并重写了其中的newBundle()方法来实现自定义资源加载逻辑。
Linux文件系统--文件类型
Ucan_Uup的博客
09-08 939
Linux中一切都是文件，文件类型有多种，使用ls -l命令可以查看文件属性，所显示结果的第一列的第一个字符用来表示文件类型，如下： 1.普通文件 第一列第一个字符为“-”的文件为普通文件。 创建普通文件我们用：touch newfile 命令 删除普通文件我们用：rm newfile 命令 2.目录文件 第一列第一个字符为“d”（directory）的文件为目录文件。 创建目录文件我们用：mkdir directory 命令 删除空目录文件我们用：rmdir directory 命令 删除非空目录文件
java代码国际化_Java系列：国际化（zz）
weixin_34014076的博客
02-21 773
国际化英文单词为：Internationalization，又称I18N，I为因为单词的第一个字母，18为这个单词的长度，而N代表这个单词的最后一个字母。国际化又称本地化(Localization,L10N)。国际化相关的Java类Java国际化主要通过如下3个类完成java.util.ResourceBundle:用于加载一个资源包java.util.Locale：对应一个特定的国家/区域、语言...
Java国际化主题大合集
CSDN文章已停止维护，后续文章会在 https://blog.hufeifei.cn 持续更新
08-05 2116
Java提供给我们软件国际化的解决方案，这些国际化API基于Unicode标准，并且包括文本、（货币）数字、日期以及用户自定义对象的适配，从而使得软件能够应用到任何国家或地区。国际化英文为“Internationalization”，通常简写成i18n(实际开发经常使用简写)。更多有关Java国际化的内容可以参考Oracle的相关网站。文字国际化Java语言基于Unicode字符集。Unicode是
(5)Java基础类库之.国际化程序实现
keep coding!!
03-29 203
​ 国际化的程序指的是同一程序代码可以根据不同的国家实现不同的语言描述，但是程序处理的核心业务是相同的。
【仿真建模-anylogic】FlowchartPort原理解析
最新发布
zhaoyaxuan001的博客
06-14 316
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
java 图像化编程
08-20
Java图像化编程是指使用Java语言的相关库和工具，实现通过图形界面来进行编程的一种方式。通过图像化编程，可以更直观地进行程序的设计和开发，使程序具备良好的用户交互性和可视化效果。 Java图像化编程的核心是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

烟雨平生9527

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值