我想输出这样一个循环,生成以下这个unicode表,小弟不知是如何实现的~请高手赐教~~~~200分如果少就再加一百~~       0 1 2 3 4 5 6 7 8 9 A B C D E F  
0000  NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI  
0010  DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US  
0020   ! " # $ % & ' ( ) * + , - . /  
0030  0 1 2 3 4 5 6 7 8 9 : ; < = > ?  
0040  @ A B C D E F G H I J K L M N O  
0050  P Q R S T U V W X Y Z [ \ ] ^ _  
0060  ` a b c d e f g h i j k l m n o  
0070  p q r s t u v w x y z { | } ~ DEL  
0080  PAD HOP BPH NBH IND NEL SSA ESA HTS HTJ VTS PLD PLU RI SS2 SS3  
0090  DCS PU1 PU2 STS CCH MW SPA EPA SOS SGCI SCI CSI ST OSC PM APC  
00A0  NBSP ¡ ¢ £ ? ¥ ¦ § ¨ © ª « ¬ SHY ® ¯  
00B0  ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿  
00C0  À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï  
00D0  Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß  
00E0  à á â ã ä å æ ç è é ê ë ì í î ï  
00F0  ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ  
      0 1 2 3 4 5 6 7 8 9 A B C D E F  
0100  Ā ā Ă ă Ą ą Ć ć Ĉ ĉ Ċ ċ Č č Ď ď  
0110  Đ đ Ē ē Ĕ ĕ Ė ė Ę ę Ě ě Ĝ ĝ Ğ ğ  
0120  Ġ ġ Ģ ģ Ĥ ĥ Ħ ħ Ĩ ĩ Ī ī Ĭ ĭ Į į  
0130  İ ı IJ ij Ĵ ĵ Ķ ķ ĸ Ĺ ĺ Ļ ļ Ľ ľ Ŀ  
0140  ŀ Ł ł Ń ń Ņ ņ Ň ň ʼn Ŋ ŋ Ō ō Ŏ ŏ  
0150  Ő ő Œ œ Ŕ ŕ Ŗ ŗ Ř ř Ś ś Ŝ ŝ Ş ş  
0160  Š š Ţ ţ Ť ť Ŧ ŧ Ũ ũ Ū ū Ŭ ŭ Ů ů  
0170  Ű ű Ų ų Ŵ ŵ Ŷ ŷ Ÿ Ź ź Ż ż Ž ž ſ  
0180  ƀ Ɓ Ƃ ƃ Ƅ ƅ Ɔ Ƈ ƈ Ɖ Ɗ Ƌ ƌ ƍ Ǝ Ə  
0190  Ɛ Ƒ ƒ Ɠ Ɣ ƕ Ɩ Ɨ Ƙ ƙ ƚ ƛ Ɯ Ɲ ƞ Ɵ  
01A0  Ơ ơ Ƣ ƣ Ƥ ƥ Ʀ Ƨ ƨ Ʃ ƪ ƫ Ƭ ƭ Ʈ Ư  
01B0  ư Ʊ Ʋ Ƴ ƴ Ƶ ƶ Ʒ Ƹ ƹ ƺ ƻ Ƽ ƽ ƾ ƿ  
01C0  ǀ ǁ ǂ ǃ DŽ Dž dž LJ Lj lj NJ Nj nj Ǎ ǎ Ǐ  
01D0  ǐ Ǒ ǒ Ǔ ǔ Ǖ ǖ Ǘ ǘ Ǚ ǚ Ǜ ǜ ǝ Ǟ ǟ  
01E0  Ǡ ǡ Ǣ ǣ Ǥ ǥ Ǧ ǧ Ǩ ǩ Ǫ ǫ Ǭ ǭ Ǯ ǯ  
01F0  ǰ DZ Dz dz Ǵ ǵ Ƕ Ƿ Ǹ ǹ Ǻ ǻ Ǽ ǽ Ǿ ǿ  
      0 1 2 3 4 5 6 7 8 9 A B C D E F  
0200  Ȁ ȁ Ȃ ȃ Ȅ ȅ Ȇ ȇ Ȉ ȉ Ȋ ȋ Ȍ ȍ Ȏ ȏ  
0210  Ȑ ȑ Ȓ ȓ Ȕ ȕ Ȗ ȗ Ș ș Ț ț Ȝ ȝ Ȟ ȟ  
0220  Ƞ ȡ Ȣ ȣ Ȥ ȥ Ȧ ȧ Ȩ ȩ Ȫ ȫ Ȭ ȭ Ȯ ȯ  
0230  Ȱ ȱ Ȳ ȳ ȴ ȵ ȶ ȷ ȸ ȹ Ⱥ Ȼ ȼ Ƚ Ⱦ ȿ  
0240  ɀ Ɂ ɂ Ƀ Ʉ Ʌ Ɇ ɇ Ɉ ɉ Ɋ ɋ Ɍ ɍ Ɏ ɏ  
0250  ɐ ɑ ɒ ɓ ɔ ɕ ɖ ɗ ɘ ə ɚ ɛ ɜ ɝ ɞ ɟ  
0260  ɠ ɡ ɢ ɣ ɤ ɥ ɦ ɧ ɨ ɩ ɪ ɫ ɬ ɭ ɮ ɯ  
0270  ɰ ɱ ɲ ɳ ɴ ɵ ɶ ɷ ɸ ɹ ɺ ɻ ɼ ɽ ɾ ɿ  
0280  ʀ ʁ ʂ ʃ ʄ ʅ ʆ ʇ ʈ ʉ ʊ ʋ ʌ ʍ ʎ ʏ  
0290  ʐ ʑ ʒ ʓ ʔ ʕ ʖ ʗ ʘ ʙ ʚ ʛ ʜ ʝ ʞ ʟ  
02A0  ʠ ʡ ʢ ʣ ʤ ʥ ʦ ʧ ʨ ʩ ʪ ʫ ʬ ʭ ʮ ʯ  
02B0  ʰ ʱ ʲ ʳ ʴ ʵ ʶ ʷ ʸ ʹ ʺ ʻ ʼ ʽ ʾ ʿ  
02C0  ˀ ˁ ˂ ˃ ˄ ˅ ˆ ˇ ˈ ˉ ˊ ˋ ˌ ˍ ˎ ˏ  
02D0  ː ˑ ˒ ˓ ˔ ˕ ˖ ˗ ˘ ˙ ˚ ˛ ˜ ˝ ˞ ˟  
02E0  ˠ ˡ ˢ ˣ ˤ ˥ ˦ ˧ ˨ ˩ ˪ ˫ ˬ ˭ ˮ ˯  
02F0  ˰ ˱ ˲ ˳ ˴ ˵ ˶ ˷ ˸ ˹ ˺ ˻ ˼ ˽ ˾ ˿  

解决方案 »

  1.   

    都不知道这些符号对应那些unicode字符,要想全部找出来,完全是体力活。
      

  2.   

    打印这个很简单啊public class Text { public static void printUnicode(int start,int end){
    int i,j;
    byte b;
    for(i=start;i<=end;i=i+0x0010){
    System.out.print(Integer.toHexString(i));
    System.out.print('\t');
    for(j=0x0000;j<=0x000f;j++){
    b = (byte)(i+j);
    System.out.print((char)b);
    System.out.print('\t');
    }
    System.out.print('\n');
    }
    }


    public static void main(String []args) {
    printUnicode(0x0000,0x02F0);
      }
    }
      

  3.   

    public class Test {
    public static void main(String args[]) {
    for(int i=0;i<=752;i+=16) {
    System.out.print(Integer.toHexString(i)+"  ");
    for(int j=0;j<=16;j++) {
    char c = (char)(i+j);
    System.out.print(c+"  ");

    }
    System.out.println();
    }

    }
    }我是这么写的 貌似没有楼上的好
      

  4.   


    public class CharEncoding {    public void print() {
            System.out.print("      0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F");System.out.println();
            for (int i = 0; i <= 12047; System.out.println()) {
                String s = "0000" + new Integer(i).toHexString(i);
                System.out.print(s.substring(s.length() - 5, s.length() - 1));
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
                System.out.print("   " + (char) i++);
            }
        }    public static void main(String[] args) throws Exception {
            new CharEncoding().print();
        }
    }
      

  5.   

    对应char就行了,共65536,包括不可见的控制字符等
    public class MainClass {
    public static void main(String[] args) {
    final String lineSeparator = System.getProperty("line.separator"); for (int i = 0x0000; i <= 0xffff; i++) {
    if (i % 0x10 == 0) {
    System.out.println(lineSeparator);
    } else {
    System.out.write('\t');
    } System.out.print((char) i);
    }

    }
    }在eclipse里的话,要把text file encoding设为UTF-8
      

  6.   

    first,一看题目就晕了…sencond,我只是个来接分的 
      

  7.   

     for(i=start;i<=end;i=i+0x0010){
                System.out.print(Integer.toHexString(i));
                System.out.print('\t');
                for(j=0x0000;j<=0x000f;j++){
                    b = (byte)(i+j);
                    System.out.print((char)b);
                    System.out.print('\t');
      

  8.   

    LZ ,不可打印的字符怎么用java输出呢,还是用switch,case 语句吧 private static String descs( char c )
            {
            if ( 'A' <= c && c <= 'Z' )
                {
                return "upper case " + String.valueOf( c );
                }
            else if ( 'a' <= c && c <= 'z' )
                {
                return "lower case " + String.valueOf( c );
                }
            else if ( '0' <= c && c <= '9' )
                {
                return "digit " + String.valueOf( c );
                }
            else
                {
                switch ( c )
                    {
                    case 0:
                        return "^@" +
                               GLUE1 +
                               "NUL" +
                               GLUE2 +
                               "<span class=\"ac\">nul</span></span>";
                    case 1:
                        return "^A" +
                               GLUE1 +
                               "SOH" +
                               GLUE2 +
                               "<span class=\"ac\">s</span>tart <span class=\"ac\">o</span>f <span class=\"ac\">h</span>eader</span>";
                    case 2:
                        return "^B" +
                               GLUE1 +
                               "STX" +
                               GLUE2 +
                               "<span class=\"ac\">s</span>tart of <span class=\"ac\">t</span>e<span class=\"ac\">x</span>t</span>";
                    case 3:
                        return "^C" +
                               GLUE1 +
                               "ETX" +
                               GLUE2 +
                               "<span class=\"ac\">e</span>nd of <span class=\"ac\">t</span>e<span class=\"ac\">x</span>t</span>";
                    case 4:
                        return "^D" +
                               GLUE1 +
                               "EOT" +
                               GLUE2 +
                               "<span class=\"ac\">e</span>nd <span class=\"ac\">o</span>f <span class=\"ac\">t</span>ransmission</span>";
                    case 5:
                        return "^E" +
                               GLUE1 +
                               "ENQ" +
                               GLUE2 +
                               "<span class=\"ac\">e</span><span class=\"ac\">nq</span>uiry</span>";
                    case 6:
                        return "^F" +
                               GLUE1 +
                               "ACK" +
                               GLUE2 +
                               "<span class=\"ac\">ack</span>nowledege</span>";
                    case 7:
                        return "^G" +
                               GLUE1 +
                               "BEL" +
                               GLUE2 +
                               "<span class=\"ac\">bel</span>l</span>";
                    case 8:
                        return "^H" +
                               GLUE1 +
                               "BS" +
                               GLUE2 +
                               "<span class=\"ac\">b</span>ack <span class=\"ac\">s</span>pace</span> [\\b]";
                    case 9:
                        return "^I" +
                               GLUE1 +
                               "HT" +
                               GLUE2 +
                               "<span class=\"ac\">h</span>orizonal <span class=\"ac\">t</span>ab</span> [\\t]";
                    case 10:
                        return "^J" +
                               GLUE1 +
                               "LF" +
                               GLUE2 +
                               "<span class=\"ac\">l</span>ine <span class=\"ac\">f</span>eed</span> [\\n]";
                    case 11:
                        return "^K" +
                               GLUE1 +
                               "VT" +
                               GLUE2 +
                               "<span class=\"ac\">v</span>ertical <span class=\"ac\">t</span>ab</span>";
                    case 12:
                        return "^L" +
                               GLUE1 +
                               "FF" +
                               GLUE2 +
                               "<span class=\"ac\">f</span>orm <span class=\"ac\">f</span>eed</span> [\\f]";
                    case 13:
                        return "^M" +
                               GLUE1 +
                               "CR" +
                               GLUE2 +
                               "<span class=\"ac\">c</span>arriage <span class=\"ac\">r</span>eturn</span> [\\r]";
                    case 14:
                        return "^N" +
                               GLUE1 +
                               "SO" +
                               GLUE2 +
                               "<span class=\"ac\">s</span>hift <span class=\"ac\">o</span>ut</span>";
                    case 15:
                        return "^O" +
                               GLUE1 +
                               "SI" +
                               GLUE2 +
                               "<span class=\"ac\">s</span>hift <span class=\"ac\">i</span>n</span>";
                    case 16:
                        return "^P" +
                               GLUE1 +
                               "DLE" +
                               GLUE2 +
                               "<span class=\"ac\">d</span>ata <span class=\"ac\">l</span>ink <span class=\"ac\">e</span>scape</span>";
                    case 17:
                        return "^Q" +
                               GLUE1 +
                               "DC1" +
                               GLUE2 +
                               "<span class=\"ac\">d</span>evice <span class=\"ac\">c</span>ontrol <span class=\"ac\">1</span></span>,"
                               + " XON resume transmission";
                    case 18:
                        return "^R" +
                               GLUE1 +
                               "DC2" +
                               GLUE2 +
                               "<span class=\"ac\">d</span>evice <span class=\"ac\">c</span>ontrol <span class=\"ac\">2</span></span>";
                    case 19:
                        return "^S" +
                               GLUE1 +
                               "DC3" +
                               GLUE2 +
                               "<span class=\"ac\">d</span>evice <span class=\"ac\">c</span>ontrol <span class=\"ac\">3</span></span>,"
                               + " XOFF pause transmission";
                    case 20:
                        return "^T" +
                               GLUE1 +
                               "DC4" +
                               GLUE2 +
                               "<span class=\"ac\">d</span>evice <span class=\"ac\">c</span>ontrol <span class=\"ac\">4</span></span>";
                    case 21:
                        return "^U" +
                               GLUE1 +
                               "NAK" +
                               GLUE2 +
                               "<span class=\"ac\">n</span>egative <span class=\"ac\">a</span>c<span class=\"ac\">k</span>nowledge</span>";
                    case 22:
                        return "^V" +
                               GLUE1 +
                               "SYN" +
                               GLUE2 +
                               "<span class=\"ac\">syn</span>chronise</span>";
                    case 23:
                        return "^W" +
                               GLUE1 +
                               "ETB" +
                               GLUE2 +
                               "<span class=\"ac\">e</span>nd <span class=\"ac\">t</span>ext <span class=\"ac\">b</span>lock</span>";
                    case 24:
                        return "^X" +
                               GLUE1 +
                               "CAN" +
                               GLUE2 +
                               "<span class=\"ac\">can</span>cel</span>";
                    case 25:
                        return "^Y" +
                               GLUE1 +
                               "EM" +
                               GLUE2 +
                               "<span class=\"ac\">e</span>nd <span class=\"ac\">m</span>essage</span>";
                    case 26:
                        return "^Z" +
                               GLUE1 +
                               "SUB" +
                               GLUE2 +
                               "<span class=\"ac\">sub</span>stitute</span>";
                    case 27:
                        return "^[" +
                               GLUE1 +
                               "ESC" +
                               GLUE2 +
                               "<span class=\"ac\">esc</span>ape</span>";
                    case 28:
                        return "^\\" +
                               GLUE1 +
                               "FS" +
                               GLUE2 +
                               "<span class=\"ac\">f</span>ile <span class=\"ac\">s</span>eparator</span>,"
                               + " usually used to groups of records.";
                    case 29:
                        return "^]" +
                               GLUE1 +
                               "GS" +
                               GLUE2 +
                               "<span class=\"ac\">g</span>roup <span class=\"ac\">s</span>eparator</span>,"
                               + " usually used to separate fields.";
                    case 30:
                        return "^^" +
                               GLUE1 +
                               "RS" +
                               GLUE2 +
                               "<span class=\"ac\">r</span>ecord <span class=\"ac\">s</span>eparator</span>,"
                               + " usually used to separate records.";