字符串编译码

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");