转换咖啡——编码转换、进制转换

最新推荐文章于 2023-01-05 16:36:45 发布
最新推荐文章于 2023-01-05 16:36:45 发布
阅读量323 收藏
点赞数
文章标签： java github 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43400414/article/details/105959042
版权

转换咖啡

进制转换

在进制转换界面实现了二、四、八、十、十六、三十二进制之间的相互转换。

在对应进制位置输入内容并点击后方按钮，即可转换为其余五种进制
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GKgogOQF-1588769994665)(http://m.qpic.cn/psc?/V128qQJn2nGVoZ/6Q9GUvwNirBpvfZFfWE*4IDRBy0qFL.iziUv*GZdptrrobVLqPB377DMgwO5L228PVDXaeRjYkwSqo6SCUe.Sw!!/b&bo=AwK4AQAAAAADB5o!&rf=viewer_4)]

编码转换

在编码转换界面，实现了Unicode,UTF-8,ASCII,Base64,URL的编码和解码。

编码：于第一个文本框内输入想要编码的内容，点击进行编码即可同时输出五种编码形式。
在这里插入图片描述

解码：于第一个文本框内输入想要解码的内容，点击进行解码即可解码，若是可以解码，则会在对于文本框内显示解码内容，反之文本框显示解码失败。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pl8DRKhy-1588769994690)(http://m.qpic.cn/psc?/V128qQJn2nGVoZ/ubiEST8aMMlZjEEUGVmWIhcJgaQbucWYmkma7DtwFk3l3H62Z2e2oSQmiw.46fC3FiKCBUhpavZCyc32TbJ2r.48PZ8TXSQwQr*cEspOA!/b&bo=AwK4AQAAAAADF4o!&rf=viewer_4)]

注意：

如果程序无法运行，大概率为使用者未正确安装和配置Java环境，请参考https://jingyan.baidu.com/article/f96699bb163475894e3c1be4.html进行配置，JDK安装包百度云版，提取码为x9fw

下载地址

https://github.com/Ku3n/SwitchCoffee

代码如下

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.util.Base64;

public class Main {
    static JFrame jfrm = new JFrame("转换咖啡");
    static Container ct = jfrm.getContentPane();
    static Image im = Toolkit.getDefaultToolkit().getImage("/icon.jpg");

    static JLabel writer1 = new JLabel("made by ku3n|李香兰");
    static JLabel email1 = new JLabel("ku3n@qq.com");
    static JLabel writer2 = new JLabel("made by ku3n|李香兰");
    static JLabel email2 = new JLabel("ku3n@qq.com");

    static JLabel lab_2 = new JLabel("二进制：");
    static JLabel lab_4 = new JLabel("四进制：");
    static JLabel lab_10 = new JLabel("十进制：");
    static JLabel lab_8 = new JLabel("八进制：");
    static JLabel lab_16 = new JLabel("十六进制：");
    static JLabel lab_32 = new JLabel("三十二进制：");

    static JLabel lab_url = new JLabel("URL编码");
    static JLabel lab_utf = new JLabel("UTF-8编码");
    static JLabel lab_ascii = new JLabel("ASCII编码");
    static JLabel lab_base64 = new JLabel("Base64编码");
    static JLabel lab_unicode = new JLabel("Unicode编码");

    static JTextField jtf_2 = new JTextField(50);
    static JTextField jtf_4 = new JTextField(50);
    static JTextField jtf_8 = new JTextField(50);
    static JTextField jtf_10 = new JTextField(50);
    static JTextField jtf_16 = new JTextField(50);
    static JTextField jtf_32 = new JTextField(50);

    static JButton jb_2 = new JButton("二进制转！");
    static JButton jb_4 = new JButton("四进制转！");
    static JButton jb_8 = new JButton("八进制转！");
    static JButton jb_10 = new JButton("十进制转！");
    static JButton jb_16 = new JButton("十六进制转！");
    static JButton jb_32 = new JButton("三十二进制转！");

    static JButton jb_decode = new JButton("进行解码");
    static JButton jb_encode = new JButton("进行编码");
    static JTextField jTextField_src = new JTextField("在此输入想要编码或者解码的内容");
    static JTextField jTextField_unicode = new JTextField();
    static JTextField jTextField_url = new JTextField();
    static JTextField jTextField_utf = new JTextField();
    static JTextField jTextField_ascii = new JTextField();
    static JTextField jTextField_base64 = new JTextField();



    static JTabbedPane tp = new JTabbedPane();
    static JPanel jpa_system = new JPanel();
    static JPanel jpa_trans = new JPanel();

    static double toDouble(char x) {
        if(x >= '0' && x<='9')
            return x - '0';
        else if(x >= 'a' && x <= 'z')
            return x - 'a' + 10 ;
        else
            return x -'A' + 10;
    }

    static char toChar(int x) {
        char x1;
        if(x >= 0 && x <= 9) {
            x1 = (char)(x + 48);
        }
        else {
            int z = x - 10;
            x1 = (char)(z + 65);
        }
        return x1;
    }

    static String transRadix(String str, int srcNum, int desNum) {
        char[] chs = new char[str.length()];
        chs = str.toCharArray();
        double product = 1.0;    // 进制的幂
        double deca = 0;       // 存为十进制中间转换
        for(int i = chs.length - 1; i >= 0; i--) {
            char ch = chs[i];
            deca += toDouble(ch) * product;
            product *= srcNum;
        }
        char[] relusts = new char[100];
        String relStr = "";
        int num = 0;
        do {
            double reout = deca % desNum;
            relusts[num++] = toChar((int)reout);
            deca = deca / desNum;
        }while(deca >= 1);          // 当十进制中间数大于1时继续计算
        relStr = relStr.valueOf(relusts,0,num);
        relStr.trim();
        StringBuffer strBuf = new StringBuffer(relStr);
        relStr = strBuf.reverse().toString();
        return relStr;
    }

    static class myLisenter implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent actionEvent) {
            String str = actionEvent.getActionCommand();
            String str2;
            double num;
            if (str.equals(jb_2.getText())) {
                str2 = jtf_2.getText();
                jtf_4.setText(transRadix(str2,2,4));
                jtf_8.setText(transRadix(str2,2,8));
                jtf_10.setText(transRadix(str2,2,10));
                jtf_16.setText(transRadix(str2,2,16));
                jtf_32.setText(transRadix(str2,2,32));
            }
            else if(str.equals(jb_4.getText())) {
                str2 = jtf_4.getText();
                jtf_2.setText(transRadix(str2,4,2));
                jtf_8.setText(transRadix(str2,4,8));
                jtf_10.setText(transRadix(str2,4,10));
                jtf_16.setText(transRadix(str2,4,16));
                jtf_32.setText(transRadix(str2,4,32));
            }
            else if(str.equals(jb_8.getText())) {
                str2 = jtf_8.getText();
                jtf_2.setText(transRadix(str2,8,2));
                jtf_4.setText(transRadix(str2,8,4));
                jtf_10.setText(transRadix(str2,8,10));
                jtf_16.setText(transRadix(str2,8,16));
                jtf_32.setText(transRadix(str2,8,32));
            }
            else if(str.equals(jb_10.getText())) {
                str2 = jtf_10.getText();
                jtf_2.setText(transRadix(str2,10,2));
                jtf_4.setText(transRadix(str2,10,4));
                jtf_8.setText(transRadix(str2,10,8));
                jtf_16.setText(transRadix(str2,10,16));
                jtf_32.setText(transRadix(str2,10,32));
            }
            else if(str.equals(jb_16.getText())) {
                str2 = jtf_16.getText();
                jtf_2.setText(transRadix(str2,16,2));
                jtf_4.setText(transRadix(str2,16,4));
                jtf_8.setText(transRadix(str2,16,8));
                jtf_10.setText(transRadix(str2,16,10));
                jtf_32.setText(transRadix(str2,16,32));
            }
            else if(str.equals(jb_32.getText())) {
                str2 = jtf_32.getText();
                jtf_2.setText(transRadix(str2,32,2));
                jtf_4.setText(transRadix(str2,32,4));
                jtf_8.setText(transRadix(str2,32,8));
                jtf_10.setText(transRadix(str2,32,10));
                jtf_16.setText(transRadix(str2,32,16));
            }
            else if(str.equals(jb_encode.getText())) {
                str2 = jTextField_src.getText();
                jTextField_ascii.setText(asciiEncode(str2));
                jTextField_base64.setText(baseEncode(str2));
                jTextField_unicode.setText(unicodeEncode(str2));
                jTextField_url.setText(urlEncode(str2));
                jTextField_utf.setText(utfEncode(str2));
            }
            else if(str.equals(jb_decode.getText())) {
                str2 = jTextField_src.getText();
                try {
                    jTextField_ascii.setText(asciiDecode(str2));
                }catch (Exception e) {
                    jTextField_ascii.setText("ASCII码转码失败");
                    System.out.println(e);
                }
                try {
                    jTextField_base64.setText(baseDecode(str2));
                }catch (Exception e) {
                    System.out.println(e);
                }
                try {
                    jTextField_unicode.setText(unicodeDecode(str2));
                }catch (Exception e) {
                    jTextField_unicode.setText("Unicode转码失败");
                    System.out.println(e);
                }
                try {
                    jTextField_url.setText(urlDecode(str2));
                }catch (Exception e) {
                    jTextField_url.setText("URL转码失败");
                    System.out.println(e);
                }
                try {
                    jTextField_utf.setText(utfDecode(str2));
                }catch (Exception e) {
                    jTextField_utf.setText("UTF-8转码失败");
                    System.out.println(e);
                }
            }
        }
    }

    static String unicodeEncode(String strSrc) {
        StringBuffer output = new StringBuffer();
        for (int i = 0; i < strSrc.length(); i++)
        {
            output.append("\\u" +Integer.toString(strSrc.charAt(i), 16));
        }
        return output.toString();
    }
    static String unicodeDecode(final String dataStr) {
        int start = 0;
        int end = 0;
        final StringBuffer buffer = new StringBuffer();
        while (start > -1) {
            end = dataStr.indexOf("\\u", start + 2);
            String charStr = "";
            if (end == -1) {
                charStr = dataStr.substring(start + 2, dataStr.length());
            }
            else {
                charStr = dataStr.substring(start + 2, end);
            }
            char letter = (char) Integer.parseInt(charStr, 16); // 16进制parse整形字符串。
            buffer.append(new Character(letter).toString());
            start = end;
        }
        return buffer.toString();
  }

    static String utfEncode(String strSrc) {
        StringBuffer output = new StringBuffer();
        for (int i = 0; i < strSrc.length(); i++)
        {
            output.append("&#x" + Integer.toString(strSrc.charAt(i), 16) +  ";");
        }
        return output.toString();
    }
    static String utfDecode(String dataStr) {
        int start = 0;
        int end = 0;
        final StringBuffer buffer = new StringBuffer();
        while (start > -1) {
            end = dataStr.indexOf("&#x", start + 3);
            String charStr = "";
            if (end == -1) {
                charStr = dataStr.substring(start + 3, dataStr.length());
                charStr = charStr.replaceAll(";", "");
            }
            else {
                charStr = dataStr.substring(start + 3, end);
                charStr = charStr.replaceAll(";", "");
            }
            char letter = (char) Integer.parseInt(charStr, 16); // 16进制parse整形字符串。
            buffer.append(new Character(letter).toString());
            start = end;
        }
        return buffer.toString();
    }

    static String asciiEncode(String strSrc) {
        StringBuilder sb = new StringBuilder();
        char[] ch = strSrc.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            sb.append(Integer.valueOf(ch[i]).intValue()).append(" ");
        }
        String[] chars = sb.toString().split(" ");
        StringBuffer strOut = new StringBuffer("\\u");
        for (int i = 0; i < chars.length; i++) {
            strOut.append(chars[i]);
            if(i == chars.length - 1)
                break;
            strOut.append("\\u");
        }
        return strOut.toString();
    }

    static String asciiDecode(String strDes) {
        int start = 0;
        int end = 0;
        final StringBuffer buffer = new StringBuffer();
        while (start > -1) {
            end = strDes.indexOf("\\u", start + 2);
            String charStr = "";
            if (end == -1) {
                charStr = strDes.substring(start + 2, strDes.length());
            }
            else {
                charStr = strDes.substring(start + 2, end);
            }
            char letter = (char) Integer.parseInt(charStr, 10); // 16进制parse整形字符串。
            buffer.append(new Character(letter).toString());
            start = end;
        }
        return buffer.toString();
    }
    public static String urlEncode(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLEncoder.encode(str, "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public static String urlDecode(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLDecoder.decode(str, "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    static String baseEncode(String strSrc) {
        Base64.Encoder encoder = Base64.getEncoder();
        String encodedText = "Base64加密失败";
        try{
            byte[] textByte = strSrc.getBytes("UTF-8");
            encodedText = encoder.encodeToString(textByte);
        }catch (Exception e) {
            System.out.println(e);
        }
        return encodedText;
    }

    static String baseDecode(String strSrc) {
        Base64.Decoder decoder = Base64.getDecoder();
        String decodedText = "Base64解密失败";
        try{
        decodedText = (new String(decoder.decode(strSrc), "UTF-8"));
        }catch (Exception e){
            System.out.println(e);
        }
        return decodedText;
    }


    public static void main(String[] args) {
        jfrm.setSize(515,440);
        jfrm.setIconImage(im);
        ct.setLayout(null);
        jpa_system.setLayout(null);
        jpa_trans.setLayout(null);

        lab_2.setBounds(20,10,80,20);
        lab_4.setBounds(20,60,80,20);
        lab_8.setBounds(20,110,80,20);
        lab_10.setBounds(20,160,80,20);
        lab_16.setBounds(20,210,80,20);
        lab_32.setBounds(20,260,80,20);

        jtf_2.setBounds(100,10,250,20);
        jtf_4.setBounds(100,60,250,20);
        jtf_8.setBounds(100,110,250,20);
        jtf_10.setBounds(100,160,250,20);
        jtf_16.setBounds(100,210,250,20);
        jtf_32.setBounds(100,260,250,20);

        jb_2.setBounds(360,10,110,20);
        jb_4.setBounds(360,60,110,20);
        jb_8.setBounds(360,110,110,20);
        jb_10.setBounds(360,160,110,20);
        jb_16.setBounds(360,210,110,20);
        jb_32.setBounds(360,260,110,20);

        jpa_system.add(lab_2);
        jpa_system.add(lab_4);
        jpa_system.add(lab_8);
        jpa_system.add(lab_10);
        jpa_system.add(lab_16);
        jpa_system.add(lab_32);

        jpa_system.add(jtf_2);
        jpa_system.add(jtf_4);
        jpa_system.add(jtf_8);
        jpa_system.add(jtf_10);
        jpa_system.add(jtf_16);
        jpa_system.add(jtf_32);

        jpa_system.add(jb_2);
        jpa_system.add(jb_4);
        jpa_system.add(jb_8);
        jpa_system.add(jb_10);
        jpa_system.add(jb_16);
        jpa_system.add(jb_32);

        jb_2.addActionListener(new myLisenter());
        jb_4.addActionListener(new myLisenter());
        jb_8.addActionListener(new myLisenter());
        jb_10.addActionListener(new myLisenter());
        jb_16.addActionListener(new myLisenter());
        jb_32.addActionListener(new myLisenter());



        jb_encode.setBounds(10,15,90,20);
        jb_decode.setBounds(10,40,90,20);
        jTextField_src.setBounds(110,10,350,50);
        jTextField_base64.setBounds(110,60,350,50);
        jTextField_unicode.setBounds(110,110,350,50);
        jTextField_url.setBounds(110,160,350,50);
        jTextField_utf.setBounds(110,210,350,50);
        jTextField_ascii.setBounds(110,260,350,50);

        lab_base64.setBounds(20,70,80,40);
        lab_unicode.setBounds(20,120,80,40);
        lab_url.setBounds(20,170,80,40);
        lab_utf.setBounds(20,220,80,40);
        lab_ascii.setBounds(20,270,80,40);

        jpa_trans.add(jTextField_ascii);
        jpa_trans.add(jTextField_base64);
        jpa_trans.add(jTextField_src);
        jpa_trans.add(jTextField_unicode);
        jpa_trans.add(jTextField_url);
        jpa_trans.add(jTextField_utf);

        jpa_trans.add(lab_ascii);
        jpa_trans.add(lab_base64);
        jpa_trans.add(lab_unicode);
        jpa_trans.add(lab_url);
        jpa_trans.add(lab_utf);

        jpa_trans.add(jb_decode);
        jpa_trans.add(jb_encode);

        writer1.setBounds(350,310,250,40);
        email1.setBounds(350,330,250,40);

        jpa_trans.add(writer1);
        jpa_trans.add(email1);

        writer2.setBounds(350,310,250,40);
        email2.setBounds(350,330,250,40);
        jpa_system.add(writer2);
        jpa_system.add(email2);


        jb_decode.addActionListener(new myLisenter());
        jb_encode.addActionListener(new myLisenter());

        tp.setBounds(0,0,500,400);
        tp.add("进制转换",jpa_system);
        tp.add("编码转换",jpa_trans);
        ct.add(tp);

        jfrm.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        jfrm.setVisible(true);


    }
}
ku3n
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机有没有32进制,32进制(32进制转换十进制)
weixin_36443241的博客
07-28 5463
比如一个例子 我写一个数字123 如果你认为他是一百二十三，那么他是十进制。一百二十三计算：1*10^2+2*10+3 在32进制下计算123到我们常用的十进制，只要把上面的.举例说明：121D=(?)32，假设大于9的数用英文小写字母顺序表示 写成32进制每位基数，按位写，写到比121大停止，个位1，高位=低位*321024 32 1 用这组数从高到低顺.32进制就有那些算数32进制定义表0-9...
进制转换
fulltimeangel的专栏
07-29 1262
<br />一、进制介绍<br />1、进制就是平时所说的逢几进1，10进制就是逢10进1，2进制就是逢2进1。<br />2进制数使用（0，1）2个基本符号<br />8进制数使用（0，1，2，3，4，5，6，7）8个基本符号<br />10进制数使用（0，1，2，3，4，5，6，7，8，9）10个基本符号<br />16进制数使用（0，1，2，3，4，5，6，7，8，9，A，B，C，D，E，F）16个基本符号<br /> <br />2、我们平时生活中常见的进制有10进制，7进制、24进制等，而计算机能
32位进制转换
weixin_45753030的博客
05-29 1855
进制转换 链接：https://ac.nowcoder.com/acm/problem/14589 来源：牛客网 题目描述 现在有一串由0 1组成的序列，你的任务是把这串0和1转化为32进制。规定 从10开始转化其所对应的大写字母。比如10 -> A 11 -> B 12 -> C ……… 31 -> V 输入描述: 有多组数据， 由一串0和1组成的序列，其长度0<n <=1000， 处理至文件结束 输出描述: 对于每一组数据，输出一行， 输出其对应的32位进制的
32位2进制转换为10进制相除
weixin_35753431的博客
01-05 830
如果想将 32 位的二进制数字转换为十进制，可以使用相除法。具体来说，把二进制数字的每一位与 2 相除，并将余数乘以当前位权(即 2 的对应次幂)加起来。 例如，想将二进制数字 1010 转换为十进制。可以这样做： $(1 \div 2) \times 2^3 + (0 \div 2) \times 2^2 + (1 \div 2) \times 2^1 + (0 \div 2) \times 2...
整数进制转换java swing
06-04
输入一个整数，按下按键，即可转换成十六进制和二进制
2-16之间的进制转换
12-01
java swing 实现2-16之间的任意进制的转换
栈的应用3——进制转化_栈；进制转换_
10-01
在计算机科学中，数据的表示和计算经常涉及不同的进制转换。栈作为一种基本的数据结构，其特点是后进先出（LIFO），在处理这类问题时展现出高效性。本主题将详细探讨如何使用栈来实现进制转换，特别是从十进制到二...
Labview 16进制转换为二进制
09-30
适用于在通讯时可以用到的实例，16进制转换为二进制，已经测试OK.
进制转换进制转换.txt
最新发布
01-08
进制转换
辅助软件 进制转换V2.1
06-16
辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 进制转换V2.1辅助软件 ...
labview进制之间相互转换
04-15
二进制数值至八进制，十进制，十六进制字符串转换； 十六进制数值至二进制，八进制，十进制字符串转换； 十进制数值至二进制，八进制，十六进制字符串转换。
简单的java整数进制转换程序
01-03
一个整数的进制转换，用的全部是JAVA封装好的类，只是练练排版 开发环境为JAVA6 里面有一个swing外观包，找的很辛苦又不会使用的可以学习下，本程序调用的是office2007外观，个人感觉很漂亮，而且我写的很多程序都用这个substance.jar观感包。 也有打包好的.jar文件,直接运行
实现十进制二进制八进制十六进制的相互转换 (Java经典编程案例)
热门推荐
数据知道的博客
07-02 3万+
计算机内部使用了二进制数据，为了节约空间，又定义了八进制和十六进制来表示二进制数据。对于普通人来说，十进制更加容易阅读，本例子将实现一个进制转换器。 package mytest; import java.awt.BorderLayout; import java.awt.EventQueue; import javax.swing.JFrame; import javax.swing.JPa...
java 做的简易进制计算器
lkwan123的博客
05-18 4226
import javax.swing.*; import java.awt.event.*; import java.awt.*; public class Scale { JFrame f; JPanel [] p=new JPanel[4]; JButton [] c=new JButton[13]; JLabel [] t=new JLabel[2]; JTextField []
（记数－进制转换－java）用－2为基做进制转换
爱.NET
09-09 104
这学期有门课叫做工程数学基础，第一章节我们学习一些关于记数的知识。 这里大致有几个概念要知道，第一为基，如10进制，10就是基，记做a，其次为数字符号集合s，这个又常常被称为a的完全剩余类，在s和a上存在一些约束关系，例如（未证明），s中最大元素的值小于｜a｜，s中元素的个数要等于｜a｜，在正整数领域，而s中的元素未必是一成不变的，如同3进制，我们可以使用0，1，2，同时也可以使用0，1，－1，...
使用Swing组件实现简单的进制转换
10-26 365
请编写图像界面程序， 用户在第一文本行输入数字， 有三个按钮，分别是计算2进制，8进制，16进制， 点击其中一个按钮，第一个文本行中的数据转换为相应进制的数显示在第二个文本行中。 import java.awt.Container; import java.awt.event.ActionEvent; import java.awt.event.ActionListene...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值