字元串編解碼

A. 霍夫曼編碼 matlab 文字編碼：輸入一段字元串（由小寫英文字母組成），通過調用函數實現對 字元串的編解碼

沒用過，但查了一下，matlab
自帶huffmancoding
的程序，基本上是你需要
1.
把測試圖像的灰度(sig)找出來，
2,
然後統計灰度的分布(p)，
3.
然後生成一個字典(dict)，
4.
然後直接就可以用huffmanenco進行編碼，
5.
再用huffmandeco進行恢復。
奇怪的是
huffman
coding不是無損壓縮么，為什麼會有損失？
等待大牛回答
sig
=
repmat([3
3
1
3
3
3
3
3
2
3],1,50);
%
Data
to
encode
symbols
=
[1
2
3];
%
Distinct
data
symbols
appearing
in
sig
p
=
[0.1
0.1
0.8];
%
Probability
of
each
data
symbol
dict
=
huffmandict(symbols,p);
%
Create
the
dictionary.
hcode
=
huffmanenco(sig,dict);
%
Encode
the
data.
dhsig
=
huffmandeco(hcode,dict);
%
Decode
the
code.

B. java里關於String的編碼與解碼

從語言編碼的角度，getBytes(charset)不是解碼、也不是編碼，是轉換。API 說的是針對數據的角度。把一個整體的String分解成byte[]了。

byte[] b2=s.getBytes("gbk");
String ss=new String(b2,"utf-8");

從GBK轉換成UTF-8。

UTF8包含更多的文字量。

C. 輸入一段英文字元串，要對英文字元串中出現的字元進行編碼，再根據其編碼進行解碼。

（1）統計字元串中出現的字元及次數；
（2）根據出現的次數作為權值，對每一個字元進行編碼；
（3）輸入一串01字元，根據編碼進行解碼。

D. 怎麼 知道 java字元串 編碼格式

這樣的測試方法是不正確的。getBytes(charset)是解碼，new String(byte[], charset)是編碼。new String(str.getBytes(charset),charset)是解碼再編碼，無論charset是什麼編碼格式，返回的字元串內容原始str是一致，因此equals方法都是返回true，達不到測試字元串編碼格式的目的。個人觀點：正確的測試姿勢應該是這樣的：

Stringcharset="xxx";//假定編碼格式
Stringstr="中文"；
booleanflag=str.equals(newString(str.getBytes(),charset));

flag為true則表明str的編碼格式是假定的編碼格式。其中說明str.getBytes()該方法就是按其自身編碼格式去解碼。其自身編碼格式跟你的操作系統編碼格式或你使用的IDE設置的文件的Text file encoding有關。

E. 用C++實現哈夫曼編碼解碼

#include<iostream>
#include<fstream>
#include<string>

using namespace std;

typedef struct HuffmanNode{//結點結構
int weight;
int parent,lchild,rchild;
}*HfmNode;

struct HuffmanTree{//哈弗曼樹
HfmNode Node;
char *Info;//存儲字元，也可放在結點結構里定義
int LeafNum;//葉結點數量
};

HuffmanTree T;//連接各模塊變數
/****************初始化(建立哈夫曼樹)函數********************/

void Initialization() //初始化
{
int WeightNum;
int i,j,pos1,pos2,max1,max2; //
int choice;
cout<<endl;
cout<<"***************** 建樹方案目錄*********************"<<endl;
cout<<"| |"<<endl;
cout<<"| 方案1:輸入N個字元和N個權值進行建樹 |"<<endl;
cout<<"| 方案2:以文檔中字元和並以各字元出現的 |"<<endl;
cout<<"| 頻度作為權值進行建樹 |"<<endl;
cout<<"***************************************************"<<endl;
lp: cout<<"選擇(輸入對應方案序號):";cin>>choice;
/********************建樹方案1 ************************************/
if(choice==1){

cout<<"輸入字元個數:";
cin>>WeightNum;

T.Node=new HuffmanNode[2*WeightNum-1]; //WeightNum權值對應的哈夫曼樹中的結點總數為2*WeightNum-1個
T.Info=new char[2*WeightNum-1];//實際只需要申請WeightNum-1；但為了實現要求（5）所以所有結點都由字元域
for(i=0;i<WeightNum;i++)
{
cout<<"請輸入第"<<i+1<<"個字元值";

cin.get ();
T.Info[i]=cin.get ();
cout<<"請輸入該字元的權值或頻度";
cin>>T.Node[i].weight; //輸入權值
T.Node[i].parent=-1; //為根結點
T.Node[i].lchild=-1; //無左孩子
T.Node[i].rchild=-1; //無右孩子
}
}
/***********************建樹方案2*******************************************************/
else if(choice==2)
{
char ch, *st,*name;
st=new char[128];//128為ASCII碼總數
name=new char[20];
cout<<"請輸入文檔名稱:";cin>>name;
cout<<endl;
cout<<"提示：請確認此文件存在或檢查文件名是否正確輸入!"<<endl;
cout<<endl;
system("pause");
ifstream infile(name);
if(!infile)
{
cout<<"文件打開失敗!"<<endl;//為什麼字元個數統計與字元歸類無法同時進行？？？？
exit(1);
}
i=0;
int k=0;//統計字元種類
while(infile.get (ch))
{

for(int j=0;j<=i;j++)
{
if(st[j]==ch) {break;}

else if(j==i){
st[k]=ch;
++k;
break;
}
}
i++;
}

infile.close();
int *count;
count=new int[k];
for(int m=0;m<k;m++)
count[m]=0;

ifstream infile1(name);
if(!infile1)
{
cout<<"文件打開失敗!"<<endl;
exit(1);
}
while(infile1.get (ch))//統計各字元在文檔中出現的次數
{

for(int j=0;j<=k;j++)
if(st[j]==ch) count[j]++;
}

infile1.close();
WeightNum=k;

T.Node=new HuffmanNode[2*WeightNum-1];
T.Info=new char[2*WeightNum-1];
for(i=0;i<WeightNum;i++)
{
T.Info[i]=st[i];
T.Node[i].weight=count[i]; //輸入權值
T.Node[i].parent=-1; //為根結點
T.Node[i].lchild=-1; //無左孩子
T.Node[i].rchild=-1; //無右孩子
}
delete st;
delete name;
delete count;
}

else {
goto lp;
}
/***************************************************************************/
for(i=WeightNum;i<2*WeightNum-1;i++) //建立哈弗曼樹
{
pos1=-1;
pos2=-1; //分別用來存放當前最小值和次小值的所在單元編號
max1=32767; //32767為整型數的最大值
max2=32767; //分別用來存放當前找到的最小值和次小值

for(j=0;j<i;j++) //在跟節點中選出權值最小的兩個
if(T.Node[j].parent==-1) //是否為根結點
if(T.Node[j].weight<max1)
{
max2=max1;
max1=T.Node[j].weight;
pos2=pos1; //修改次小值所在單元編號
pos1=j; //修改最小值所在單元編號
}
else
if(T.Node[j].weight<max2) //比原最小值大但比原次小值要小
{
max2=T.Node[j].weight; //存放次小值
pos2=j; //修改次小值所在的單元編號
}
//for
T.Node[pos1].parent=i; //修改根節點位置
T.Node[pos2].parent=i;
T.Node[i].lchild=pos1; //修改兒子節點位置
T.Node[i].rchild=pos2;
T.Node[i].parent=-1; //表示新結點應該是根結點
T.Node[i].weight=T.Node[pos1].weight+T.Node[pos2].weight;
}
T.LeafNum=WeightNum;

ofstream outfile("hfmTree.dat");
if(!outfile)
{
cout<<"打開文件失敗!"<<endl;
return;
}
outfile.write((char*)&WeightNum,sizeof(WeightNum)); //寫入字元個數
for(i=0;i<WeightNum;i++) //把各字元信息寫入文件

outfile.write((char*)&T.Info[i],sizeof(T.Info[i]));

for(i=0;i<2*WeightNum-1;i++) //把個節點內容寫入文件

outfile.write((char*)&T.Node[i],sizeof(T.Node[i]));

outfile.close();

cout<<"已建立哈夫曼樹!"<<endl;

}
/****************編碼函數********************/
void Encoding(){

if(T.Node==NULL) //哈夫曼樹不在內存，從文件hfmTree中讀入
{
ifstream infile0; //以二進制方式打開hfmTree.dat文件
infile0.open("hfmTree.dat",ios::binary|ios::in);
if(infile0.fail())
{
cout<<"文件打開失敗！\n";
return;
}
infile0.read((char*)&T.LeafNum,sizeof(T.LeafNum)); //讀取葉子數

T.Info=new char[T.LeafNum];
T.Node=new HuffmanNode[2*T.LeafNum-1];

for(int i=0;i<T.LeafNum;i++) //讀取字元信息
infile0.read((char*)&T.Info[i],sizeof(T.Info[i]));

for(i=0;i<2*T.LeafNum-1;i++) //讀取結點信息
infile0.read((char*)&T.Node[i],sizeof(T.Node[i]));

infile0.close();
}
char *Tree; //用於存儲需編碼內容
int i=0,k=0;
cout<<" _________________"<<endl;
cout<<" | 測試數據選擇: |"<<endl;
cout<<" | |"<<endl;
cout<<" | A:另輸入內容測試|"<<endl;
cout<<" | |"<<endl;
cout<<" | B:用ToBeTran文件|"<<endl;
cout<<" | 內容測試! |"<<endl;
cout<<" |_________________|"<<endl;
cout<<"你的選擇(不分大小寫):";
char c;
cin>>c;// tag
if(c=='A'||c=='a')
{
string ch;
cout<<"請輸入測試數據(輸入完畢按兩次回車):"<<endl;

cin.ignore();//跳過tag 處輸入的字元<--........................*//否則運行結果很意外y因為c也被添加至string中
getline(cin,ch,'\n'); //回車鍵作為輸入結束條件。所以輸入結束時按兩次回車，
//第一次作為分界符，第二次通知流對象cin已輸入一行字元

while(ch[k]!='\0')//統計輸入字元個數
k++;

Tree=new char[k+1];
k=0;
while(ch[k]!='\0')//將輸入的內容存到Tree中
{
Tree[k]=ch[k];
k++;
}
Tree[k]='\0';

cout<<"需編碼內容為:";
cout<<Tree<<endl;

}

else{
ifstream infile1("ToBeTran.txt");
if(!infile1)
{
cout<<"文件打開失敗!\n";
return;
}
char ch;
int k=0;
// infile1>>noskipws;
while(infile1.get(ch))
{
k++; //計算ToBeTran中正文長度，以便確定Tree的空間大小
}
infile1.close();
Tree=new char[k+1];
ifstream infile2("ToBeTran.txt");

k=0;
// infile2>>noskipws;
while(infile2.get(ch))
{
Tree[k]=ch; //讀取文件內容，並存到Tree中
k++;
}
infile2.close();

Tree[k]='\0';//結束標志

cout<<"需編碼內容為:";
cout<<Tree<<endl;
}

ofstream outfile("CodeFile.txt"); //存儲編碼後的代碼,並覆蓋原文件
if(T.Node==NULL) //還未建哈夫曼樹
{
cout<<"警告+提示：請先建樹!\n";
return;
}
char *code;
code=new char[T.LeafNum]; //為所產生編碼分配容量為T.LeafNum的存儲空間
k=0;
while(Tree[k]!='\0')
{
int j,start=0;
for(i=0;i<T.LeafNum;i++)
if(T.Info[i]==Tree[k]) //求出該文字所在單元的編號
break;
j=i;
while(T.Node[j].parent!=-1) //結點j非樹根
{
j=T.Node[j].parent; //非結點j的雙親結點
if(T.Node[j].lchild==i) //是左子樹，則生成代碼0
code[start++]='0';
else //是右子樹，則生成代碼1
code[start++]='1';
i=j;
}

int m=start-1;
while(m>=0) //存儲哈弗曼編碼
{

outfile<<code[m];
m--;
}
k++;

}

outfile.close();
cout<<"已編碼！且編碼形式內容已存到文件CodeFile.txt中!\n\n";
delete Tree;
delete code;
} //Encoding
/****************解碼函數********************/
void Decoding()

{

int i=0,k=0;
int j=T.LeafNum*2-1-1; //從根結點開始往下搜索
char* str;
char ch;
ifstream infile1("CodeFile.txt"); //利用已建好的哈夫曼樹將文件CodeFile中的代碼進行解碼
if(!infile1)
{
cout<<"請先編碼!\n";
return;
}
cout<<"經解碼,原內容為:";

while(infile1.get(ch))
{
k++; //計算CodeFile中代碼長度
}
infile1.close();

str=new char[k+1];

ifstream infile2("CodeFile.txt");
k=0;

while(infile2.get(ch))
{
str[k]=ch; //讀取文件內容
k++;
}
infile2.close();
str[k]='\0'; //結束標志符
if(T.Node==NULL) //還未建哈夫曼樹
{
cout<<"請先編碼!\n";
return;
}
ofstream outfile("TextFile.txt"); //將字元形式的編碼文件寫入文件Textfile中
while(str[i]!='\0')
{
if(str[i]=='0')
j=T.Node[j].lchild; //往左走
else
j=T.Node[j].rchild; //往右走
if(T.Node[j].rchild==-1) //到達葉子結點
{
cout<<T.Info[j]; //輸出葉子結點對應的字元

outfile.put(T.Info[j]);
j=T.LeafNum*2-1-1; //存入文件
}
i++;
}
outfile.close();
delete str;

cout<<"\n解碼成功且其內容已存到文件TextFile.txt中！\n\n";
}//Decoding
/****************印代碼函數********************/

void Print1(){
char ch;
ifstream infile("Codefile.txt");//
if(!infile)
{
cout<<"未進行編碼"<<endl;
return;
}
ofstream outfile("CodePrin.txt");//
if(!outfile)
{
cout<<"打開失敗!"<<endl;
return;
}
int i=0;
int j=T.LeafNum*2-1-1;
while(infile.get(ch))
{
cout<<ch;
i++;
if(i==50)
{i=0;
cout<<endl;
}
if(ch=='0')
j=T.Node[j].lchild; //往左走
else
j=T.Node[j].rchild; //往右走
if(T.Node[j].rchild==-1) //到達葉子結點
{
//輸出葉子結點對應的字元
outfile.put(T.Info[j]); //存入文件

j=T.LeafNum*2-1-1;
}
}
cout<<endl;
infile.close();
outfile.close();
cout<<"相應的字元形式的編碼文件已寫入CodePrin.txt中!"<<endl;
}//Print()
/****************印哈夫曼樹函數********************/
void Tree_Printing(){
if(T.Node==NULL) //未建立哈夫曼樹
{
cout<<"請先建立哈夫曼樹！\n";
return;
}
cout<<"所建立的哈夫曼樹的凹入表形式為："<<endl;
ofstream fop("TreePrint.txt");
cout<<"位置:權值(字元) "<<"左孩子位置(權值) "<<"右孩子位置(權值)\n";
fop<<"位置:權值(字元) "<<"左孩子位置 (權值) "<<"右孩子位置(權值)\n";
int i;
for(i=0;i<T.LeafNum;i++)
{
cout<<i<<":"<<T.Node[i].weight<<"("<<T.Info[i]<<") \n";
fop<<i<<":"<<T.Node[i].weight<<"("<<T.Info[i]<<") \n";
}
for(i=T.LeafNum;i<(2*T.LeafNum-1);i++) //輸出哈夫曼樹
{
cout<<i<<":"<<T.Node[i].weight<<"(#)"<<"-------"
<<T.Node[i].lchild<<"("<<T.Node[T.Node[i].lchild].weight<<")"<<"------"
<<T.Node[i].rchild<<"("<<T.Node[T.Node[i].rchild].weight<<")"<<endl;

fop<<i<<":"<<T.Node[i].weight<<"(#)"<<"------"
<<T.Node[i].lchild<<"("<<T.Node[T.Node[i].lchild].weight<<")"<<"------"
<<T.Node[i].rchild<<"("<<T.Node[T.Node[i].rchild].weight<<")"<<endl;
}

}
/*

/****************哈夫曼編碼表:********************/
void Print(){
cout<<"哈夫曼編碼表:"<<endl;

char *code;
code=new char[T.LeafNum];
int i=0;

while(i<T.LeafNum)
{
cout<<T.Info [i]<<":";
int j,start=0;
int k;
k=i;
j=k;
while(T.Node[j].parent!=-1) //結點j非樹根
{
j=T.Node[j].parent; //非結點j的雙親結點
if(T.Node[j].lchild==k) //是左子樹，則生成代碼0
code[start++]='0';
else //是右子樹，則生成代碼1
code[start++]='1';
k=j;
}
for(int n=start-1;n>=0;n--)
cout<<code[n];

i++;
cout<<endl;
}

delete code;
}
/****************操作界面函數************************************************************/
void Screen_display(){
char ch;
do{
cout<<"*******************************************************************************"<<endl;
cout<<" 哈夫曼編碼/解碼系統"<<endl;
cout<<endl;
cout<<" 操作指令目錄"<<endl;
cout<<endl;
cout<<" I:初始化(建立哈夫曼樹) E:編碼 D:解碼 P:印代碼 T:印哈夫曼樹 Q:退出系統"<<endl;
cout<<endl;
cout<<"版本:V1.0"<<endl;
cout<<"*******************************************************************************"<<endl;
cout<<endl;

cout<<"輸入相應操作的指令(不分大小寫):"<<endl;
cin>>ch;
switch(ch)
{
case'I':
case'i':cout<<" 現在進行'初始化'操作:"<<endl;Initialization();break;
case'E':
case'e':cout<<" 現在進行'編碼'操作: "<<endl;Encoding();break;
case'D':
case'd':cout<<" 現在進行'解碼'操作: "<<endl;Decoding();break;
case'P':
case'p':cout<<" 現在進行'印代碼'操作: "<<endl;Print1();break;
case't':
case'T':{Tree_Printing();cout<<endl;Print();break;}
case'Q':
case'q':cout<<"謝謝使用!"<<endl;exit(1);break;
}
}while(1);
}
/****************主函數********************/
void main(){
Screen_display();
}

F. C 語言 霍夫曼編碼

#include<stdio.h>
#include<string.h>

/*
本題要求各函數的參數使用指針

假設字母a、b、c、d、e、f的霍夫曼編碼分別是1、00、011、0100、01010、01011。那麼字元串「abcdef」的編碼顯然就是字元串「10001101000101001011」。

（1）編寫編碼函數實現對字元串「abcdef」的編碼，顯示編碼結果。
（2）編寫解碼函數對剛才得到的編碼進行解碼，顯示解碼結果。
（3）假設有一段編碼「010111011010100100010010100」，請對其解碼，並顯示解碼結果。
*/

charhufman[6][10]={
	{"a1"},
	{"b00"},
	{"c011"},
	{"d0100"},
	{"e01010"},
	{"f01011"},
};


voidcode(char*src,char*dest)	
{
	inti;
	intlen=0;
	while(*src!='')
	{
		for(i=0;i<6;i++)
		{
			if(*src==hufman[i][0])
			{
				strcpy(dest+len,hufman[i]+1);
				len+=strlen(hufman[i]+1);
				break;
			}
		}
		src++;
	}
}


voiddecode(char*src,char*dest)
{
	inti;
	intlen=0;
	while(*src!='')
	{
		for(i=0;i<6;i++)
		{
			if(strncmp(src,hufman[i]+1,strlen(hufman[i]+1))==0)
			{
				dest[len++]=hufman[i][0];
				src+=strlen(hufman[i]+1);
				break;
			}
		}
	}
	dest[len]=0;
}


intmain(intargc,char*argv[])
{
	char*str="abcdef";
	char*str1="010111011010100100010010100";
	charres[100]={0};
	chardecodeRes[20];
	code(str,res);
	printf("%s
",res);

	decode(res,decodeRes);

	printf("%s
",decodeRes);

	decode(str1,decodeRes);

	printf("%s
",decodeRes);

}

G. JAVA字元串編碼問題！

這種編碼問題真是很tricky的問題。說它tricky是因為這至少涉及到以下4種編碼選取的排列組合(有時甚至更多)，更有時乃至會發生錯進錯出，負負得正，中間過程錯了但反而到不是亂碼的情況。

(1)源代碼的編碼
(2)編譯時告訴java編譯器的源代碼編碼
(3)運行時jvm參數file.encoding
(4)輸出終端對輸出位元組流的解碼所採用的碼組

在這簡單情況下(1)和(2)一致，(3)和(4)一致就不會因為編解碼映射錯誤(當然字元向終端字體映射的錯誤是另一回事，如字體缺失之類)。而(1)(2)和(3)(4)不必一致，這樣就使得不必強求開發編譯環境和運行應用環境的編碼必須一致。

源代碼的錄入與編譯若在在一個平台上時，大多數情況沒有問題(反而用聰明的Idea IDE設置錯誤時會亂套，越是簡陋的開發環境越不太會錯)。但是如果你在中文GBK編碼平台上的源代碼在別人的unicode編碼平台上編譯，就有問題了。所以和別人，特別是和不同母語的人合作編程時，建議要麼約定一律用unicode作為源文件編碼；要麼只用ASCII字元，反正其他編碼一般都和ASCII兼容的，對於非ASCII字元，用Java的/uxxxx表示機制，比如"中國"就表示為"\u4e2d\u56fd"。4e2d和56fd分別是中國二字的unicode十六進制編碼。

但我認為樓主在這里其實主要關心的是運行時的編碼一致問題，即(3)和(4)。所以言歸正傳，讓我們來檢查它們是否一致。

由於正如上述，iso8859-1編碼集其實是被其他所有公認的編碼集所兼容的，也就是說它是所有公認編碼集的公共子集。所以以iso8859-1為基礎可以外延到任何一個公認編碼集。事實上大多數情況也是這樣做的。比如java System property里設定了encoding為iso8859-1，事實上不僅僅是一個Latin字母的映射，在非Latin區域按JVM宿主操作系統的編碼擴展。即選iso8859-1其實是選擇了宿主操作系統的默認編碼。

假設樓主的操作系統編碼是GBK,那麼file.encoding=iso8859-1相當於選擇了file.encoding=GBK。那麼System.out.println(...)這個核心類方法會將china字元轉換為file.encoding指定的編碼(GBK)位元組由out流輸出給最終out所綁定的終端。比如console一般採用系統默認編碼也是GBK的話，那就和file.encoding一致，能正常解碼，不會亂碼。

至於System.out.write()直接寫位元組流。由於該位元組流是由china.getBytes()得到的，在不指定編碼的時候使用file.encoding指定的默認值的(即GBK)，因此Str->Byte的編碼方法GBK和console採用的解碼方法GBK又是一致的，所以也不是亂碼。

但是這時候用toHexString列印出的兩個位元組串是不一樣的。先直接把china逐字強行轉換為int的情況，不涉及輸出編碼，總是unicode的。(JVM規范規定class里字串必須unicode編碼)只要上述(1) (2)匹配，java編譯器會自動從各種編碼的源文件正確轉成class文件里統一unicode編碼的字串。相反，作為一個題外話提一下，當(1)(2)不匹配時會在特定的一種配合(1)(2)的(3)(4)也不匹配的情況下會負負得正輸出正常，但這是絕對錯誤的做法，因為任何要求(1)(2)和(3)(4)有匹配關系的要求都是在應用中可能無法滿足的。java編譯器對這種情況也會報告warning，但不fail。

綜上，一旦file.encoding設成宿主操作系統默認而系統consle也採用操作系統默認編解碼的話，(3)(4)總是一致的，無論系統選擇的是GBK還是utf-8等等。

那麼如果file.encoding不選系統默認呢？比如utf-8。那就很可能出現亂碼了。但是，慢著，試驗的結果還是沒有亂碼。那是因為file.encoding是靜態的JVM系統參數，在程序里像樓主那樣設定是不起作用的(我不知道有沒有辦法發一個什麼通知讓這種程序改變生效的)。必須作為JVM參數直接傳給java程序讓它構造虛擬機的時候就得到這個參數，否則JVM會去拿宿主系統的默認值，就相當於又回到設file.encoding=iso8859-1了。
java -Dfile.encoding=utf-8 A
這下終於亂碼了，而且兩個都亂了。列印出的位元組串一個還是unicode，另一個從GBK變到utf-8了。

如果你發現試驗的現象和我上面說的正好相反，請注意檢查console的編碼設置，我們上面假設它也採用了宿主系統默認編碼，但有些console很高級的嘞，可以設置成不通編碼的(其實幾乎所有的都可以)。那麼分析的方法和上面一樣，結果可能正好相反。

H. 請問java如何改變字元串的編碼方式

byte[] b=string.getBytes("GB2312");//使用GB2312編碼方式對字元串string進行編碼
//這時要想將位元組數組b的內容正確解碼只能使用GB2312的編碼方式進行解碼，即
String str=new String(b,"GB2312");//這里若使用UTF-8編碼方式來進行解碼就會亂碼
//將eclipse默認的編碼方式改為UTF-8，只是用該編碼方式對.java源文件進行編碼保存
//這個對new String(string.getBytes("GB2312"),"UTF-8")沒啥影響的
//因為從java源文件獲取字元串string時，已經通過UTF-8編碼方式進行解碼了
//而string.getBytes("GB2312")是使用指定的編碼方式對字元串string進行從新編碼
//這兩者之間沒啥關系的

I. 對一個9個英文字元的字元串進行什麼演算法的編碼,獲得的結果字元串最短

統計字元串中出現的字元及次數； 根據出現的次數作為權值，對每一個字元進行編碼； 輸入一串01字元，根據編碼進行解碼。

編碼（Encoding）是一種計算機編程語言的代碼，是信息從一種形式或格式轉換為另一種形式的過程。

通常是用預先規定的方法將文字、數字或其他對象編成數碼，或將信息、數據轉換成規定的電脈沖信號。編碼在電子計算機、電視、遙控和通訊等方面廣泛使用。

J. java中編碼與解碼分別指什麼

java中編碼：URLEncoder.encode(strUri,"utf-8");

java中解碼碼：URLDecoder.decode(strUri,"utf-8");