SQL 标准
 
SQL 定义了两种基本的字符类型：character varying(n) 和 character(n) ，这里的 n 是一个正整数。两种类型都可以存储最多 n 个字符的字符串。试图存储更长的字符串到这些类型的字段里会产生一个错误，除非超出长度的字符都是空白，这种情况下该字符串将被截断为最大长度。这个看上去有点怪异的例外是 SQL 标准要求的。如果要存储的字符串比声明的长度短，类型为 character 的数值将会用空白填满；而类型为 character varying 的数值将只是存储短些的字符串。
 
如果我们明确地把一个数值转换成 character varying(n) 或 character(n) ，那么超长的数值将被截断成 n 个字符，且不会抛出错误。这也是 SQL 标准的要求。
 
postgreSQL 字符类型
 
Name
Description
character varying(n), varchar(n)
变长，有长度限制
character(n), char(n)
定长，不足补空白
text
变长，无长度限制
长度区别
 
varchar(n) 和 char(n) 分别是 character varying(n) 和 character(n) 的别名，没有声明长度的 character 等于 character(1) ；character varying 不带长度使用 ，那么该类型接受任何长度的字符串。后者是 PostgreSQL 的扩展。
 
另外，PostgreSQL 提供 text 类型，它可以存储任何长度的字符串。尽管text类型不是 SQL 标准，但是许多 SQL 数据库系统也有它。
 
物理存储
 
character 类型的数据，在物理上都用空格（原文: space）填充到指定长度 n 并且以这种方式存储和显示。不过，填充的空白在是无语意的。在比较两个 character 值的时候，填充的空白都会被忽略，在转换成其它字符串类型的时候，character 值里面的空格会被删除。请注意，在 character varying 和 text 类型的数据里，结尾的空白是有语意的。
 
这些类型的存储需求是 4 字节加上实际的字符串，如果是 character 的话再加上填充的字节（上面提到的空格）。长字符串将会自动被系统压缩，因此在磁盘上的物理需求可能会更少些。长字符串也会存储在后台表里面，这样它们就不会干扰对短字段的快速访问（我的理解是：磁盘寻址路径或者次数更少？有知道的还望指出！！！）。不管怎样，允许存储的最长字符串大概是 1GB 。允许在数据类型声明中出现的 n 的最大值小于该最大值。更改此值不是很有用，因为使用多字节字符编码时，字符和字节数可能会完全不同。如果你想存储没有特定上限的长字符串，那么使用 text 或没有长度声明词的 character varying ，而不要设定长度限制。
 
性能差异
 
这三种类型之间没有性能差别，只不过是在使用 character 的时候增加了存储尺寸。虽然在某些其它的数据库系统里，character(n) 有一定的性能优势，但在 PostgreSQL 里没有。在大多数情况下，应该使用 text 或 character varying 。
 
参考：pg 8.2.23文档

 
 
Unknown initial character set index '255' received from server. Initial client character set can be forced via the 'characterEncoding' property.
 
从错误的提示信息中发现字符集设置出现问题
 
 
 
 
 
mysql连接数据库时报此错误：
 
//String url = "jdbc:mysql://localhost:3306/db_cjky" 如果使用这句就会报错。
 //Unknown initial character set index '255' received from server. Initial client character set can be forced via the 'characterEncoding' property.
String url = "jdbc:mysql://localhost:3306/db_cjky?useUnicode=true&characterEncoding=utf8";//改成这句，就可以了
 
 
 
最终解决方法：
 
删除 \WebContent\WEB-INF\lib目录下的。mysql-connector的jar文件。原因是：MySQL驱动和数据库字符集设置不搭配
 
 
 
再补充一下,如果是在mybatis配置文件中的话应该修改成jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8
 
 
 
 
 
 
 
 
 
 
package com.lyq.bean;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

/**
 * ��Ʒ���ݿ����
 * @author Li YongQiang
 *
 */

public class BookDao {
	/**
	 * ��ȡ���ݿ�����
	 * @return Connection����
	 */
	public Connection getConnection(){
		// ���ݿ�����
		Connection conn = null;
		try {
			// �������ݿ�������ע�ᵽ����������
			Class.forName("com.mysql.jdbc.Driver");
			// ���ݿ������ַ���
			//String url = "jdbc:mysql://localhost:3306/db_cjky" 如果使用这句就会报错。
			//Unknown initial character set index '255' received from server. Initial client character set can be forced via the 'characterEncoding' property.
			String url = "jdbc:mysql://localhost:3306/db_cjky?useUnicode=true&characterEncoding=utf8";//改成这句，就可以了。
			// ���ݿ��û���
			String username = "root";
			// ���ݿ�����
			String password = "123456";
			// ����Connection����
			conn = DriverManager.getConnection(url,username,password);
			if(conn!=null)
			{System.out.println("database is good, you are good");}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		// �������ݿ�����
		return conn;
	}
	
	/**
	 * ��ҳ��ѯ������Ʒ��Ϣ
	 * @param page ҳ��
	 * @return List<Product>
	 */
	public List<Product> find(int page){
		// ����List
		List<Product> list = new ArrayList<Product>();
		// ��ȡ���ݿ�����
		Connection conn = getConnection();
		// ��ҳ��ѯ��SQL���
		String sql = "select * from tb_product order by id limit ?,?";
		try {
			// ��ȡPreparedStatement
			PreparedStatement ps = conn.prepareStatement(sql);
			ps.setInt(1, (page - 1) * Product.PAGE_SIZE);
			// ��SQL����еĵ�2��������ֵ
			ps.setInt(2, Product.PAGE_SIZE);
			// ִ�в�ѯ����
			ResultSet rs = ps.executeQuery();
			// �������ƶ������ж��Ƿ���Ч
			while(rs.next()){
				// ʵ����Product
				Product p = new Product();
				// ��id���Ը�ֵ
				p.setId(rs.getInt("id"));
				// ��name���Ը�ֵ
				p.setName(rs.getString("name"));
				// ��num���Ը�ֵ
				p.setNum(rs.getInt("num"));
				// ��price���Ը�ֵ
				p.setPrice(rs.getDouble("price"));
				// ��unit���Ը�ֵ
				p.setUnit(rs.getString("unit"));
				// ��Product��ӵ�List������
				list.add(p);
			}
			// �ر�ResultSet
			rs.close();
			// �ر�PreparedStatement
			ps.close();
			// �ر�Connection
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return list;
	}
	
	/**
	 * ��ѯ�ܼ�¼��
	 * @return �ܼ�¼��
	 */
	public int findCount(){
		// �ܼ�¼��
		int count = 0;
		// ��ȡ���ݿ�����
		Connection conn = getConnection();
		// ��ѯ�ܼ�¼��SQL���
		String sql = "select count(*) from tb_product";
		try {
			// ����Statement
			Statement stmt = conn.createStatement();
			// ��ѯ����ȡResultSet
			ResultSet rs = stmt.executeQuery(sql);
			// �������ƶ������ж��Ƿ���Ч
			if(rs.next()){
				// ���ܼ�¼����ֵ
				count = rs.getInt(1);
			}
			// �ر�ResultSet
			rs.close();
			// �ر�Connection
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		// �����ܼ�¼��
		return count;
	}
}
 
 

package api;

public class CharacterApi {

	public static void main(String[] args) {
		Character character = new Character('a');
		Character character1 = new Character('d');
		character1 = Character.valueOf('b');
		
		System.out.println(character.equals('a'));
		
		int n = character.compareTo(character1);  // 'a' - 'd';
		// 等效于 Character.compare(character, character1); -3
		//System.out.println(n);  // -3
		
		boolean b = Character.isWhitespace(' '); // 是否为空字符
		//System.out.println(b); // true
		
		char c3 = Character.toUpperCase(character); // 大写  不是英文字符返回本身
		//System.out.println(c3);  // 'A'  
		c3 = Character.toLowerCase('A');  // 'a'
		n = Character.toUpperCase(97); // 大写 'a'
		//System.out.println(n); // 65-- 'A'
		n = Character.toLowerCase(65); // 'a' 不是英文字符返回本身
		//System.out.println(n);         // 97 
		
		b = Character.isLetterOrDigit(' ');  // 判断是否是数字或字母
		System.out.println(b);
		b = Character.isLetterOrDigit('1');  // 
		System.out.println(b);
		
		b = Character.isLetter('a'); // 判断是否是字母
		System.out.println(b);
		
		b = Character.isDigit('2'); // 判断是否为数字
		System.out.println(b);
		
		b = Character.isUpperCase('A'); // 判断是否为大写
		b = Character.isLowerCase('a'); // 判断是否为小写
	}

}

类型
说明
character varying(n), varchar(n)
变长，有长度限制
character(n), char(n)
定长，不足补空白
text
变长，无长度限制
    SQL定义了两种基本的字符类型：character varying(n)和character(n)，这里的n是一个正整数。两种类型都可以存储最多n个字符的字符串。试图存储更长的字符串到这些类型的字段里会产生一个错误，除非超出长度的字符都是空白，这种情况下该字符串将被截断为最大长度。这个看上去有点怪异的例外是SQL标准要求的。如果要存储的字符串比声明的长度短，类型为character的数值将会用空白填满；而类型为character varying的数值将只是存储短些的字符串。
 
    如果我们明确地把一个数值转换成character varying(n)或character(n)，那么超长的数值将被截断成n个字符，且不会抛出错误。这也是SQL标准的要求。
 
    varchar(n)和char(n)分别是character varying(n)和character(n)的别名，没有声明长度的character等于character(1)；如果不带长度说明词使用character varying，那么该类型接受任何长度的字符串。后者是PostgreSQL的扩展。
 
    另外，PostgreSQL提供text类型，它可以存储任何长度的字符串。尽管类型text不是SQL标准，但是许多其它SQL数据库系统也有它。
 
    character类型的数值物理上都用空白填充到指定的长度n并且以这种方式存储和显示。不过，填充的空白在是无语意的。在比较两个character值的时候，填充的空白都不会被关注，在转换成其它字符串类型的时候，character值里面的空白会被删除。请注意，在character varying和text数值里，结尾的空白是有语意的。
 
    这些类型的存储需求是4字节加上实际的字符串，如果是character的话再加上填充的字节。长的字符串将会自动被系统压缩，因此在磁盘上的物理需求可能会更少些。长的数值也会存储在后台表里面，这样它们就不会干扰对短字段值的快速访问。不管怎样，允许存储的最长字符串大概是1GB。允许在数据类型声明中出现的n的最大值比这还小。修改这个行为没有什么意义，因为在多字节编码下字符和字节的数目可能差别很大。如果你想存储没有特定上限的长字符串，那么使用text或没有长度声明词的character varying，而不要选择一个任意长度限制。
 
    这三种类型之间没有性能差别，只不过是在使用character的时候增加了存储尺寸。虽然在某些其它的数据库系统里，character(n)有一定的性能优势，但在PostgreSQL里没有。在大多数情况下，应该使用text或character varying。